﻿using System;
using System.Collections.Generic;

using System.Text;
using System.Xml.Serialization;
using System.Data;
using System.Collections;
using System.CodeDom.Compiler;
using System.Runtime.Serialization;
using System.Diagnostics;
using System.Xml.Schema;
using System.Xml;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.IO;

namespace AuroraLightsFX
{
[Serializable, XmlRoot("ThemeDataset"), XmlSchemaProvider("GetTypedDataSetSchema"), ToolboxItem(true), GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0"), HelpKeyword("vs.data.DataSet"), DesignerCategory("code")]
public class ThemeDataset : DataSet
{
    // Fields
    private SchemaSerializationMode _schemaSerializationMode;
    private DataRelation relationActions_ActionTypes;
    private DataRelation relationActions_Zones;
    private DataRelation relationLeds_Groups;
    private DataRelation relationPseudoActionVisualization_ActionTypes;
    private DataRelation relationPseudoActionVisualization_Visualizations;
    private DataRelation relationVisualizations_Theme;
    private DataRelation relationVisualizations_VisualizationTypes;
    private DataRelation relationZones_Visualizations;
    private DataRelation relationZonesGroups_Groups;
    private DataRelation relationZonesGroups_Zones;
    private ActionsDataTable tableActions;
    private ActionTypesDataTable tableActionTypes;
    private GroupsDataTable tableGroups;
    private LedsDataTable tableLeds;
    private PseudoActionVisualizationDataTable tablePseudoActionVisualization;
    private ThemeDataTable tableTheme;
    private VisualizationsDataTable tableVisualizations;
    private VisualizationTypesDataTable tableVisualizationTypes;
    private ZonesDataTable tableZones;
    private ZonesGroupsDataTable tableZonesGroups;

    // Methods
    [DebuggerNonUserCode]
    public ThemeDataset()
    {
        this._schemaSerializationMode = SchemaSerializationMode.IncludeSchema;
        base.BeginInit();
        this.InitClass();
        CollectionChangeEventHandler handler = new CollectionChangeEventHandler(this.SchemaChanged);
        base.Tables.CollectionChanged += handler;
        base.Relations.CollectionChanged += handler;
        base.EndInit();
    }

    [DebuggerNonUserCode]
    protected ThemeDataset(SerializationInfo info, StreamingContext context) : base(info, context, false)
    {
        this._schemaSerializationMode = SchemaSerializationMode.IncludeSchema;
        if (base.IsBinarySerialized(info, context))
        {
            this.InitVars(false);
            CollectionChangeEventHandler handler = new CollectionChangeEventHandler(this.SchemaChanged);
            this.Tables.CollectionChanged += handler;
            this.Relations.CollectionChanged += handler;
        }
        else
        {
            string s = (string) info.GetValue("XmlSchema", typeof(string));
            if (base.DetermineSchemaSerializationMode(info, context) == SchemaSerializationMode.IncludeSchema)
            {
                DataSet dataSet = new DataSet();
                dataSet.ReadXmlSchema(new XmlTextReader(new StringReader(s)));
                if (dataSet.Tables["Actions"] != null)
                {
                    base.Tables.Add(new ActionsDataTable(dataSet.Tables["Actions"]));
                }
                if (dataSet.Tables["ZonesGroups"] != null)
                {
                    base.Tables.Add(new ZonesGroupsDataTable(dataSet.Tables["ZonesGroups"]));
                }
                if (dataSet.Tables["ActionTypes"] != null)
                {
                    base.Tables.Add(new ActionTypesDataTable(dataSet.Tables["ActionTypes"]));
                }
                if (dataSet.Tables["Groups"] != null)
                {
                    base.Tables.Add(new GroupsDataTable(dataSet.Tables["Groups"]));
                }
                if (dataSet.Tables["Leds"] != null)
                {
                    base.Tables.Add(new LedsDataTable(dataSet.Tables["Leds"]));
                }
                if (dataSet.Tables["PseudoActionVisualization"] != null)
                {
                    base.Tables.Add(new PseudoActionVisualizationDataTable(dataSet.Tables["PseudoActionVisualization"]));
                }
                if (dataSet.Tables["Theme"] != null)
                {
                    base.Tables.Add(new ThemeDataTable(dataSet.Tables["Theme"]));
                }
                if (dataSet.Tables["Visualizations"] != null)
                {
                    base.Tables.Add(new VisualizationsDataTable(dataSet.Tables["Visualizations"]));
                }
                if (dataSet.Tables["VisualizationTypes"] != null)
                {
                    base.Tables.Add(new VisualizationTypesDataTable(dataSet.Tables["VisualizationTypes"]));
                }
                if (dataSet.Tables["Zones"] != null)
                {
                    base.Tables.Add(new ZonesDataTable(dataSet.Tables["Zones"]));
                }
                base.DataSetName = dataSet.DataSetName;
                base.Prefix = dataSet.Prefix;
                base.Namespace = dataSet.Namespace;
                base.Locale = dataSet.Locale;
                base.CaseSensitive = dataSet.CaseSensitive;
                base.EnforceConstraints = dataSet.EnforceConstraints;
                base.Merge(dataSet, false, MissingSchemaAction.Add);
                this.InitVars();
            }
            else
            {
                base.ReadXmlSchema(new XmlTextReader(new StringReader(s)));
            }
            base.GetSerializationData(info, context);
            CollectionChangeEventHandler handler2 = new CollectionChangeEventHandler(this.SchemaChanged);
            base.Tables.CollectionChanged += handler2;
            this.Relations.CollectionChanged += handler2;
        }
    }

    [DebuggerNonUserCode]
    public override DataSet Clone()
    {
        ThemeDataset dataset = (ThemeDataset) base.Clone();
        dataset.InitVars();
        dataset.SchemaSerializationMode = this.SchemaSerializationMode;
        return dataset;
    }

    [DebuggerNonUserCode]
    protected override XmlSchema GetSchemaSerializable()
    {
        MemoryStream w = new MemoryStream();
        base.WriteXmlSchema(new XmlTextWriter(w, null));
        w.Position = 0L;
        return XmlSchema.Read(new XmlTextReader(w), null);
    }

    [DebuggerNonUserCode]
    public static XmlSchemaComplexType GetTypedDataSetSchema(XmlSchemaSet xs)
    {
        ThemeDataset dataset = new ThemeDataset();
        XmlSchemaComplexType type = new XmlSchemaComplexType();
        XmlSchemaSequence sequence = new XmlSchemaSequence();
        XmlSchemaAny item = new XmlSchemaAny();
        item.Namespace = dataset.Namespace;
        sequence.Items.Add(item);
        type.Particle = sequence;
        XmlSchema schemaSerializable = dataset.GetSchemaSerializable();
        if (xs.Contains(schemaSerializable.TargetNamespace))
        {
            MemoryStream stream = new MemoryStream();
            MemoryStream stream2 = new MemoryStream();
            try
            {
                XmlSchema current = null;
                schemaSerializable.Write(stream);
                IEnumerator enumerator = xs.Schemas(schemaSerializable.TargetNamespace).GetEnumerator();
                while (enumerator.MoveNext())
                {
                    current = (XmlSchema) enumerator.Current;
                    stream2.SetLength(0L);
                    current.Write(stream2);
                    if (stream.Length == stream2.Length)
                    {
                        stream.Position = 0L;
                        stream2.Position = 0L;
                        while ((stream.Position != stream.Length) && (stream.ReadByte() == stream2.ReadByte()))
                        {
                        }
                        if (stream.Position == stream.Length)
                        {
                            return type;
                        }
                    }
                }
            }
            finally
            {
                if (stream != null)
                {
                    stream.Close();
                }
                if (stream2 != null)
                {
                    stream2.Close();
                }
            }
        }
        xs.Add(schemaSerializable);
        return type;
    }

    [DebuggerNonUserCode]
    private void InitClass()
    {
        base.DataSetName = "ThemeDataset";
        base.Prefix = "";
        base.Namespace = "http://tempuri.org/ThemeDataset.xsd";
        base.EnforceConstraints = true;
        this.SchemaSerializationMode = SchemaSerializationMode.IncludeSchema;
        this.tableActions = new ActionsDataTable();
        base.Tables.Add(this.tableActions);
        this.tableZonesGroups = new ZonesGroupsDataTable();
        base.Tables.Add(this.tableZonesGroups);
        this.tableActionTypes = new ActionTypesDataTable();
        base.Tables.Add(this.tableActionTypes);
        this.tableGroups = new GroupsDataTable();
        base.Tables.Add(this.tableGroups);
        this.tableLeds = new LedsDataTable();
        base.Tables.Add(this.tableLeds);
        this.tablePseudoActionVisualization = new PseudoActionVisualizationDataTable();
        base.Tables.Add(this.tablePseudoActionVisualization);
        this.tableTheme = new ThemeDataTable();
        base.Tables.Add(this.tableTheme);
        this.tableVisualizations = new VisualizationsDataTable();
        base.Tables.Add(this.tableVisualizations);
        this.tableVisualizationTypes = new VisualizationTypesDataTable();
        base.Tables.Add(this.tableVisualizationTypes);
        this.tableZones = new ZonesDataTable();
        base.Tables.Add(this.tableZones);
        this.relationActions_ActionTypes = new DataRelation("Actions_ActionTypes", new DataColumn[] { this.tableActionTypes.ActionTypeIDColumn }, new DataColumn[] { this.tableActions.ActionTypeIDColumn }, false);
        this.Relations.Add(this.relationActions_ActionTypes);
        this.relationActions_Zones = new DataRelation("Actions_Zones", new DataColumn[] { this.tableZones.ZoneIDColumn }, new DataColumn[] { this.tableActions.ZoneIDColumn }, false);
        this.Relations.Add(this.relationActions_Zones);
        this.relationZonesGroups_Groups = new DataRelation("ZonesGroups_Groups", new DataColumn[] { this.tableGroups.GroupIDColumn }, new DataColumn[] { this.tableZonesGroups.GroupIDColumn }, false);
        this.Relations.Add(this.relationZonesGroups_Groups);
        this.relationZonesGroups_Zones = new DataRelation("ZonesGroups_Zones", new DataColumn[] { this.tableZones.ZoneIDColumn }, new DataColumn[] { this.tableZonesGroups.ZoneIDColumn }, false);
        this.Relations.Add(this.relationZonesGroups_Zones);
        this.relationLeds_Groups = new DataRelation("Leds_Groups", new DataColumn[] { this.tableGroups.GroupIDColumn }, new DataColumn[] { this.tableLeds.GroupIDColumn }, false);
        this.Relations.Add(this.relationLeds_Groups);
        this.relationPseudoActionVisualization_ActionTypes = new DataRelation("PseudoActionVisualization_ActionTypes", new DataColumn[] { this.tableActionTypes.ActionTypeIDColumn }, new DataColumn[] { this.tablePseudoActionVisualization.ActionTypeIDColumn }, false);
        this.Relations.Add(this.relationPseudoActionVisualization_ActionTypes);
        this.relationPseudoActionVisualization_Visualizations = new DataRelation("PseudoActionVisualization_Visualizations", new DataColumn[] { this.tableVisualizations.VisualizationIDColumn }, new DataColumn[] { this.tablePseudoActionVisualization.VisualizationIDColumn }, false);
        this.Relations.Add(this.relationPseudoActionVisualization_Visualizations);
        this.relationVisualizations_Theme = new DataRelation("Visualizations_Theme", new DataColumn[] { this.tableTheme.ThemeIDColumn }, new DataColumn[] { this.tableVisualizations.ThemeIDColumn }, false);
        this.Relations.Add(this.relationVisualizations_Theme);
        this.relationVisualizations_VisualizationTypes = new DataRelation("Visualizations_VisualizationTypes", new DataColumn[] { this.tableVisualizationTypes.VisualizationTypeIDColumn }, new DataColumn[] { this.tableVisualizations.VisualizationTypeIDColumn }, false);
        this.Relations.Add(this.relationVisualizations_VisualizationTypes);
        this.relationZones_Visualizations = new DataRelation("Zones_Visualizations", new DataColumn[] { this.tableVisualizations.VisualizationIDColumn }, new DataColumn[] { this.tableZones.VisualizationIDColumn }, false);
        this.Relations.Add(this.relationZones_Visualizations);
    }

    [DebuggerNonUserCode]
    protected override void InitializeDerivedDataSet()
    {
        base.BeginInit();
        this.InitClass();
        base.EndInit();
    }

    [DebuggerNonUserCode]
    internal void InitVars()
    {
        this.InitVars(true);
    }

    [DebuggerNonUserCode]
    internal void InitVars(bool initTable)
    {
        this.tableActions = (ActionsDataTable) base.Tables["Actions"];
        if (initTable && (this.tableActions != null))
        {
            this.tableActions.InitVars();
        }
        this.tableZonesGroups = (ZonesGroupsDataTable) base.Tables["ZonesGroups"];
        if (initTable && (this.tableZonesGroups != null))
        {
            this.tableZonesGroups.InitVars();
        }
        this.tableActionTypes = (ActionTypesDataTable) base.Tables["ActionTypes"];
        if (initTable && (this.tableActionTypes != null))
        {
            this.tableActionTypes.InitVars();
        }
        this.tableGroups = (GroupsDataTable) base.Tables["Groups"];
        if (initTable && (this.tableGroups != null))
        {
            this.tableGroups.InitVars();
        }
        this.tableLeds = (LedsDataTable) base.Tables["Leds"];
        if (initTable && (this.tableLeds != null))
        {
            this.tableLeds.InitVars();
        }
        this.tablePseudoActionVisualization = (PseudoActionVisualizationDataTable) base.Tables["PseudoActionVisualization"];
        if (initTable && (this.tablePseudoActionVisualization != null))
        {
            this.tablePseudoActionVisualization.InitVars();
        }
        this.tableTheme = (ThemeDataTable) base.Tables["Theme"];
        if (initTable && (this.tableTheme != null))
        {
            this.tableTheme.InitVars();
        }
        this.tableVisualizations = (VisualizationsDataTable) base.Tables["Visualizations"];
        if (initTable && (this.tableVisualizations != null))
        {
            this.tableVisualizations.InitVars();
        }
        this.tableVisualizationTypes = (VisualizationTypesDataTable) base.Tables["VisualizationTypes"];
        if (initTable && (this.tableVisualizationTypes != null))
        {
            this.tableVisualizationTypes.InitVars();
        }
        this.tableZones = (ZonesDataTable) base.Tables["Zones"];
        if (initTable && (this.tableZones != null))
        {
            this.tableZones.InitVars();
        }
        this.relationActions_ActionTypes = this.Relations["Actions_ActionTypes"];
        this.relationActions_Zones = this.Relations["Actions_Zones"];
        this.relationZonesGroups_Groups = this.Relations["ZonesGroups_Groups"];
        this.relationZonesGroups_Zones = this.Relations["ZonesGroups_Zones"];
        this.relationLeds_Groups = this.Relations["Leds_Groups"];
        this.relationPseudoActionVisualization_ActionTypes = this.Relations["PseudoActionVisualization_ActionTypes"];
        this.relationPseudoActionVisualization_Visualizations = this.Relations["PseudoActionVisualization_Visualizations"];
        this.relationVisualizations_Theme = this.Relations["Visualizations_Theme"];
        this.relationVisualizations_VisualizationTypes = this.Relations["Visualizations_VisualizationTypes"];
        this.relationZones_Visualizations = this.Relations["Zones_Visualizations"];
    }

    [DebuggerNonUserCode]
    protected override void ReadXmlSerializable(XmlReader reader)
    {
        if (base.DetermineSchemaSerializationMode(reader) == SchemaSerializationMode.IncludeSchema)
        {
            this.Reset();
            DataSet dataSet = new DataSet();
            dataSet.ReadXml(reader);
            if (dataSet.Tables["Actions"] != null)
            {
                base.Tables.Add(new ActionsDataTable(dataSet.Tables["Actions"]));
            }
            if (dataSet.Tables["ZonesGroups"] != null)
            {
                base.Tables.Add(new ZonesGroupsDataTable(dataSet.Tables["ZonesGroups"]));
            }
            if (dataSet.Tables["ActionTypes"] != null)
            {
                base.Tables.Add(new ActionTypesDataTable(dataSet.Tables["ActionTypes"]));
            }
            if (dataSet.Tables["Groups"] != null)
            {
                base.Tables.Add(new GroupsDataTable(dataSet.Tables["Groups"]));
            }
            if (dataSet.Tables["Leds"] != null)
            {
                base.Tables.Add(new LedsDataTable(dataSet.Tables["Leds"]));
            }
            if (dataSet.Tables["PseudoActionVisualization"] != null)
            {
                base.Tables.Add(new PseudoActionVisualizationDataTable(dataSet.Tables["PseudoActionVisualization"]));
            }
            if (dataSet.Tables["Theme"] != null)
            {
                base.Tables.Add(new ThemeDataTable(dataSet.Tables["Theme"]));
            }
            if (dataSet.Tables["Visualizations"] != null)
            {
                base.Tables.Add(new VisualizationsDataTable(dataSet.Tables["Visualizations"]));
            }
            if (dataSet.Tables["VisualizationTypes"] != null)
            {
                base.Tables.Add(new VisualizationTypesDataTable(dataSet.Tables["VisualizationTypes"]));
            }
            if (dataSet.Tables["Zones"] != null)
            {
                base.Tables.Add(new ZonesDataTable(dataSet.Tables["Zones"]));
            }
            base.DataSetName = dataSet.DataSetName;
            base.Prefix = dataSet.Prefix;
            base.Namespace = dataSet.Namespace;
            base.Locale = dataSet.Locale;
            base.CaseSensitive = dataSet.CaseSensitive;
            base.EnforceConstraints = dataSet.EnforceConstraints;
            base.Merge(dataSet, false, MissingSchemaAction.Add);
            this.InitVars();
        }
        else
        {
            base.ReadXml(reader);
            this.InitVars();
        }
    }

    [DebuggerNonUserCode]
    private void SchemaChanged(object sender, CollectionChangeEventArgs e)
    {
        if (e.Action == CollectionChangeAction.Remove)
        {
            this.InitVars();
        }
    }

    [DebuggerNonUserCode]
    private bool ShouldSerializeActions()
    {
        return false;
    }

    [DebuggerNonUserCode]
    private bool ShouldSerializeActionTypes()
    {
        return false;
    }

    [DebuggerNonUserCode]
    private bool ShouldSerializeGroups()
    {
        return false;
    }

    [DebuggerNonUserCode]
    private bool ShouldSerializeLeds()
    {
        return false;
    }

    [DebuggerNonUserCode]
    private bool ShouldSerializePseudoActionVisualization()
    {
        return false;
    }

    [DebuggerNonUserCode]
    protected override bool ShouldSerializeRelations()
    {
        return false;
    }

    [DebuggerNonUserCode]
    protected override bool ShouldSerializeTables()
    {
        return false;
    }

    [DebuggerNonUserCode]
    private bool ShouldSerializeTheme()
    {
        return false;
    }

    [DebuggerNonUserCode]
    private bool ShouldSerializeVisualizations()
    {
        return false;
    }

    [DebuggerNonUserCode]
    private bool ShouldSerializeVisualizationTypes()
    {
        return false;
    }

    [DebuggerNonUserCode]
    private bool ShouldSerializeZones()
    {
        return false;
    }

    [DebuggerNonUserCode]
    private bool ShouldSerializeZonesGroups()
    {
        return false;
    }

    // Properties
    [DebuggerNonUserCode, Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
    public ActionsDataTable Actions
    {
        get
        {
            return this.tableActions;
        }
    }

    [DesignerSerializationVisibility(DesignerSerializationVisibility.Content), DebuggerNonUserCode, Browsable(false)]
    public ActionTypesDataTable ActionTypes
    {
        get
        {
            return this.tableActionTypes;
        }
    }

    [Browsable(false), DebuggerNonUserCode, DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
    public GroupsDataTable Groups
    {
        get
        {
            return this.tableGroups;
        }
    }

    [DesignerSerializationVisibility(DesignerSerializationVisibility.Content), Browsable(false), DebuggerNonUserCode]
    public LedsDataTable Leds
    {
        get
        {
            return this.tableLeds;
        }
    }

    [DebuggerNonUserCode, Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
    public PseudoActionVisualizationDataTable PseudoActionVisualization
    {
        get
        {
            return this.tablePseudoActionVisualization;
        }
    }

    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), DebuggerNonUserCode]
    public new DataRelationCollection Relations
    {
        get
        {
            return base.Relations;
        }
    }

    [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible), Browsable(true), DebuggerNonUserCode]
    public override SchemaSerializationMode SchemaSerializationMode
    {
        get
        {
            return this._schemaSerializationMode;
        }
        set
        {
            this._schemaSerializationMode = value;
        }
    }

    [DebuggerNonUserCode, DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
    public new DataTableCollection Tables
    {
        get
        {
            return base.Tables;
        }
    }

    [DesignerSerializationVisibility(DesignerSerializationVisibility.Content), Browsable(false), DebuggerNonUserCode]
    public ThemeDataTable Theme
    {
        get
        {
            return this.tableTheme;
        }
    }

    [DesignerSerializationVisibility(DesignerSerializationVisibility.Content), Browsable(false), DebuggerNonUserCode]
    public VisualizationsDataTable Visualizations
    {
        get
        {
            return this.tableVisualizations;
        }
    }

    [DesignerSerializationVisibility(DesignerSerializationVisibility.Content), DebuggerNonUserCode, Browsable(false)]
    public VisualizationTypesDataTable VisualizationTypes
    {
        get
        {
            return this.tableVisualizationTypes;
        }
    }

    [DesignerSerializationVisibility(DesignerSerializationVisibility.Content), Browsable(false), DebuggerNonUserCode]
    public ZonesDataTable Zones
    {
        get
        {
            return this.tableZones;
        }
    }

    [DesignerSerializationVisibility(DesignerSerializationVisibility.Content), Browsable(false), DebuggerNonUserCode]
    public ZonesGroupsDataTable ZonesGroups
    {
        get
        {
            return this.tableZonesGroups;
        }
    }

    // Nested Types
    [Serializable, XmlSchemaProvider("GetTypedTableSchema"), GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
    public class ActionsDataTable : DataTable, IEnumerable
    {
        // Fields
        private DataColumn columnActionID;
        private DataColumn columnActionTypeID;
        private DataColumn columnColor1;
        private DataColumn columnColor2;
        private DataColumn columnDuration;
        private DataColumn columnZoneID;

        // Events
        public event ThemeDataset.ActionsRowChangeEventHandler ActionsRowChanged;

        public event ThemeDataset.ActionsRowChangeEventHandler ActionsRowChanging;

        public event ThemeDataset.ActionsRowChangeEventHandler ActionsRowDeleted;

        public event ThemeDataset.ActionsRowChangeEventHandler ActionsRowDeleting;

        // Methods
        [DebuggerNonUserCode]
        public ActionsDataTable()
        {
            base.TableName = "Actions";
            this.BeginInit();
            this.InitClass();
            this.EndInit();
        }

        [DebuggerNonUserCode]
        internal ActionsDataTable(DataTable table)
        {
            base.TableName = table.TableName;
            if (table.CaseSensitive != table.DataSet.CaseSensitive)
            {
                base.CaseSensitive = table.CaseSensitive;
            }
            if (table.Locale.ToString() != table.DataSet.Locale.ToString())
            {
                base.Locale = table.Locale;
            }
            if (table.Namespace != table.DataSet.Namespace)
            {
                base.Namespace = table.Namespace;
            }
            base.Prefix = table.Prefix;
            base.MinimumCapacity = table.MinimumCapacity;
        }

        [DebuggerNonUserCode]
        protected ActionsDataTable(SerializationInfo info, StreamingContext context) : base(info, context)
        {
            this.InitVars();
        }

        [DebuggerNonUserCode]
        public void AddActionsRow(ThemeDataset.ActionsRow row)
        {
            base.Rows.Add(row);
        }

        [DebuggerNonUserCode]
        public ThemeDataset.ActionsRow AddActionsRow(ThemeDataset.ZonesRow parentZonesRowByActions_Zones, ThemeDataset.ActionTypesRow parentActionTypesRowByActions_ActionTypes, string Color1, string Color2, int Duration)
        {
            ThemeDataset.ActionsRow row = (ThemeDataset.ActionsRow) base.NewRow();
            object[] objArray2 = new object[6];
            objArray2[3] = Color1;
            objArray2[4] = Color2;
            objArray2[5] = Duration;
            object[] objArray = objArray2;
            if (parentZonesRowByActions_Zones != null)
            {
                objArray[0] = parentZonesRowByActions_Zones[1];
            }
            if (parentActionTypesRowByActions_ActionTypes != null)
            {
                objArray[2] = parentActionTypesRowByActions_ActionTypes[0];
            }
            row.ItemArray = objArray;
            base.Rows.Add(row);
            return row;
        }

        [DebuggerNonUserCode]
        public override DataTable Clone()
        {
            ThemeDataset.ActionsDataTable table = (ThemeDataset.ActionsDataTable) base.Clone();
            table.InitVars();
            return table;
        }

        [DebuggerNonUserCode]
        protected override DataTable CreateInstance()
        {
            return new ThemeDataset.ActionsDataTable();
        }

        [DebuggerNonUserCode]
        public ThemeDataset.ActionsRow FindByActionID(int ActionID)
        {
            return (ThemeDataset.ActionsRow) base.Rows.Find(new object[] { ActionID });
        }

        [DebuggerNonUserCode]
        public virtual IEnumerator GetEnumerator()
        {
            return base.Rows.GetEnumerator();
        }

        [DebuggerNonUserCode]
        protected override Type GetRowType()
        {
            return typeof(ThemeDataset.ActionsRow);
        }

        [DebuggerNonUserCode]
        public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs)
        {
            XmlSchemaComplexType type = new XmlSchemaComplexType();
            XmlSchemaSequence sequence = new XmlSchemaSequence();
            ThemeDataset dataset = new ThemeDataset();
            XmlSchemaAny item = new XmlSchemaAny();
            item.Namespace = "http://www.w3.org/2001/XMLSchema";
            item.MinOccurs = 0M;
            item.MaxOccurs = 79228162514264337593543950335M;
            item.ProcessContents = XmlSchemaContentProcessing.Lax;
            sequence.Items.Add(item);
            XmlSchemaAny any2 = new XmlSchemaAny();
            any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
            any2.MinOccurs = 1M;
            any2.ProcessContents = XmlSchemaContentProcessing.Lax;
            sequence.Items.Add(any2);
            XmlSchemaAttribute attribute = new XmlSchemaAttribute();
            attribute.Name = "namespace";
            attribute.FixedValue = dataset.Namespace;
            type.Attributes.Add(attribute);
            XmlSchemaAttribute attribute2 = new XmlSchemaAttribute();
            attribute2.Name = "tableTypeName";
            attribute2.FixedValue = "ActionsDataTable";
            type.Attributes.Add(attribute2);
            type.Particle = sequence;
            XmlSchema schemaSerializable = dataset.GetSchemaSerializable();
            if (xs.Contains(schemaSerializable.TargetNamespace))
            {
                MemoryStream stream = new MemoryStream();
                MemoryStream stream2 = new MemoryStream();
                try
                {
                    XmlSchema current = null;
                    schemaSerializable.Write(stream);
                    IEnumerator enumerator = xs.Schemas(schemaSerializable.TargetNamespace).GetEnumerator();
                    while (enumerator.MoveNext())
                    {
                        current = (XmlSchema) enumerator.Current;
                        stream2.SetLength(0L);
                        current.Write(stream2);
                        if (stream.Length == stream2.Length)
                        {
                            stream.Position = 0L;
                            stream2.Position = 0L;
                            while ((stream.Position != stream.Length) && (stream.ReadByte() == stream2.ReadByte()))
                            {
                            }
                            if (stream.Position == stream.Length)
                            {
                                return type;
                            }
                        }
                    }
                }
                finally
                {
                    if (stream != null)
                    {
                        stream.Close();
                    }
                    if (stream2 != null)
                    {
                        stream2.Close();
                    }
                }
            }
            xs.Add(schemaSerializable);
            return type;
        }

        [DebuggerNonUserCode]
        private void InitClass()
        {
            this.columnZoneID = new DataColumn("ZoneID", typeof(int), null, MappingType.Element);
            base.Columns.Add(this.columnZoneID);
            this.columnActionID = new DataColumn("ActionID", typeof(int), null, MappingType.Element);
            base.Columns.Add(this.columnActionID);
            this.columnActionTypeID = new DataColumn("ActionTypeID", typeof(int), null, MappingType.Element);
            base.Columns.Add(this.columnActionTypeID);
            this.columnColor1 = new DataColumn("Color1", typeof(string), null, MappingType.Element);
            base.Columns.Add(this.columnColor1);
            this.columnColor2 = new DataColumn("Color2", typeof(string), null, MappingType.Element);
            base.Columns.Add(this.columnColor2);
            this.columnDuration = new DataColumn("Duration", typeof(int), null, MappingType.Element);
            base.Columns.Add(this.columnDuration);
            base.Constraints.Add(new UniqueConstraint("Constraint1", new DataColumn[] { this.columnActionID }, true));
            this.columnZoneID.AllowDBNull = false;
            this.columnActionID.AutoIncrement = true;
            this.columnActionID.AllowDBNull = false;
            this.columnActionID.ReadOnly = true;
            this.columnActionID.Unique = true;
            this.columnActionTypeID.AllowDBNull = false;
            this.columnColor1.AllowDBNull = false;
            this.columnColor1.MaxLength = 9;
            this.columnColor2.AllowDBNull = false;
            this.columnColor2.MaxLength = 9;
            this.columnDuration.AllowDBNull = false;
        }

        [DebuggerNonUserCode]
        internal void InitVars()
        {
            this.columnZoneID = base.Columns["ZoneID"];
            this.columnActionID = base.Columns["ActionID"];
            this.columnActionTypeID = base.Columns["ActionTypeID"];
            this.columnColor1 = base.Columns["Color1"];
            this.columnColor2 = base.Columns["Color2"];
            this.columnDuration = base.Columns["Duration"];
        }

        [DebuggerNonUserCode]
        public ThemeDataset.ActionsRow NewActionsRow()
        {
            return (ThemeDataset.ActionsRow) base.NewRow();
        }

        [DebuggerNonUserCode]
        protected override DataRow NewRowFromBuilder(DataRowBuilder builder)
        {
            return new ThemeDataset.ActionsRow(builder);
        }

        [DebuggerNonUserCode]
        protected override void OnRowChanged(DataRowChangeEventArgs e)
        {
            base.OnRowChanged(e);
            if (this.ActionsRowChanged != null)
            {
                this.ActionsRowChanged(this, new ThemeDataset.ActionsRowChangeEvent((ThemeDataset.ActionsRow) e.Row, e.Action));
            }
        }

        [DebuggerNonUserCode]
        protected override void OnRowChanging(DataRowChangeEventArgs e)
        {
            base.OnRowChanging(e);
            if (this.ActionsRowChanging != null)
            {
                this.ActionsRowChanging(this, new ThemeDataset.ActionsRowChangeEvent((ThemeDataset.ActionsRow) e.Row, e.Action));
            }
        }

        [DebuggerNonUserCode]
        protected override void OnRowDeleted(DataRowChangeEventArgs e)
        {
            base.OnRowDeleted(e);
            if (this.ActionsRowDeleted != null)
            {
                this.ActionsRowDeleted(this, new ThemeDataset.ActionsRowChangeEvent((ThemeDataset.ActionsRow) e.Row, e.Action));
            }
        }

        [DebuggerNonUserCode]
        protected override void OnRowDeleting(DataRowChangeEventArgs e)
        {
            base.OnRowDeleting(e);
            if (this.ActionsRowDeleting != null)
            {
                this.ActionsRowDeleting(this, new ThemeDataset.ActionsRowChangeEvent((ThemeDataset.ActionsRow) e.Row, e.Action));
            }
        }

        [DebuggerNonUserCode]
        public void RemoveActionsRow(ThemeDataset.ActionsRow row)
        {
            base.Rows.Remove(row);
        }

        // Properties
        [DebuggerNonUserCode]
        public DataColumn ActionIDColumn
        {
            get
            {
                return this.columnActionID;
            }
        }

        [DebuggerNonUserCode]
        public DataColumn ActionTypeIDColumn
        {
            get
            {
                return this.columnActionTypeID;
            }
        }

        [DebuggerNonUserCode]
        public DataColumn Color1Column
        {
            get
            {
                return this.columnColor1;
            }
        }

        [DebuggerNonUserCode]
        public DataColumn Color2Column
        {
            get
            {
                return this.columnColor2;
            }
        }

        [Browsable(false), DebuggerNonUserCode]
        public int Count
        {
            get
            {
                return base.Rows.Count;
            }
        }

        [DebuggerNonUserCode]
        public DataColumn DurationColumn
        {
            get
            {
                return this.columnDuration;
            }
        }

        [DebuggerNonUserCode]
        public ThemeDataset.ActionsRow this[int index]
        {
            get
            {
                return (ThemeDataset.ActionsRow) base.Rows[index];
            }
        }

        [DebuggerNonUserCode]
        public DataColumn ZoneIDColumn
        {
            get
            {
                return this.columnZoneID;
            }
        }
    }

    [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
    public class ActionsRow : DataRow
    {
        // Fields
        private ThemeDataset.ActionsDataTable tableActions;

        // Methods
        [DebuggerNonUserCode]
        internal ActionsRow(DataRowBuilder rb) : base(rb)
        {
            this.tableActions = (ThemeDataset.ActionsDataTable) base.Table;
        }

        // Properties
        [DebuggerNonUserCode]
        public int ActionID
        {
            get
            {
                return (int) base[this.tableActions.ActionIDColumn];
            }
            set
            {
                base[this.tableActions.ActionIDColumn] = value;
            }
        }

        [DebuggerNonUserCode]
        public int ActionTypeID
        {
            get
            {
                return (int) base[this.tableActions.ActionTypeIDColumn];
            }
            set
            {
                base[this.tableActions.ActionTypeIDColumn] = value;
            }
        }

        [DebuggerNonUserCode]
        public ThemeDataset.ActionTypesRow ActionTypesRow
        {
            get
            {
                return (ThemeDataset.ActionTypesRow) base.GetParentRow(base.Table.ParentRelations["Actions_ActionTypes"]);
            }
            set
            {
                base.SetParentRow(value, base.Table.ParentRelations["Actions_ActionTypes"]);
            }
        }

        [DebuggerNonUserCode]
        public string Color1
        {
            get
            {
                return (string) base[this.tableActions.Color1Column];
            }
            set
            {
                base[this.tableActions.Color1Column] = value;
            }
        }

        [DebuggerNonUserCode]
        public string Color2
        {
            get
            {
                return (string) base[this.tableActions.Color2Column];
            }
            set
            {
                base[this.tableActions.Color2Column] = value;
            }
        }

        [DebuggerNonUserCode]
        public int Duration
        {
            get
            {
                return (int) base[this.tableActions.DurationColumn];
            }
            set
            {
                base[this.tableActions.DurationColumn] = value;
            }
        }

        [DebuggerNonUserCode]
        public int ZoneID
        {
            get
            {
                return (int) base[this.tableActions.ZoneIDColumn];
            }
            set
            {
                base[this.tableActions.ZoneIDColumn] = value;
            }
        }

        [DebuggerNonUserCode]
        public ThemeDataset.ZonesRow ZonesRow
        {
            get
            {
                return (ThemeDataset.ZonesRow) base.GetParentRow(base.Table.ParentRelations["Actions_Zones"]);
            }
            set
            {
                base.SetParentRow(value, base.Table.ParentRelations["Actions_Zones"]);
            }
        }
    }

    [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
    public class ActionsRowChangeEvent : EventArgs
    {
        // Fields
        private DataRowAction eventAction;
        private ThemeDataset.ActionsRow eventRow;

        // Methods
        [DebuggerNonUserCode]
        public ActionsRowChangeEvent(ThemeDataset.ActionsRow row, DataRowAction action)
        {
            this.eventRow = row;
            this.eventAction = action;
        }

        // Properties
        [DebuggerNonUserCode]
        public DataRowAction Action
        {
            get
            {
                return this.eventAction;
            }
        }

        [DebuggerNonUserCode]
        public ThemeDataset.ActionsRow Row
        {
            get
            {
                return this.eventRow;
            }
        }
    }

    public delegate void ActionsRowChangeEventHandler(object sender, ThemeDataset.ActionsRowChangeEvent e);

    [Serializable, XmlSchemaProvider("GetTypedTableSchema"), GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
    public class ActionTypesDataTable : DataTable, IEnumerable
    {
        // Fields
        private DataColumn columnActionTypeID;
        private DataColumn columnName;
        private DataColumn columnPseudoAction;

        // Events
        public event ThemeDataset.ActionTypesRowChangeEventHandler ActionTypesRowChanged;

        public event ThemeDataset.ActionTypesRowChangeEventHandler ActionTypesRowChanging;

        public event ThemeDataset.ActionTypesRowChangeEventHandler ActionTypesRowDeleted;

        public event ThemeDataset.ActionTypesRowChangeEventHandler ActionTypesRowDeleting;

        // Methods
        [DebuggerNonUserCode]
        public ActionTypesDataTable()
        {
            base.TableName = "ActionTypes";
            this.BeginInit();
            this.InitClass();
            this.EndInit();
        }

        [DebuggerNonUserCode]
        internal ActionTypesDataTable(DataTable table)
        {
            base.TableName = table.TableName;
            if (table.CaseSensitive != table.DataSet.CaseSensitive)
            {
                base.CaseSensitive = table.CaseSensitive;
            }
            if (table.Locale.ToString() != table.DataSet.Locale.ToString())
            {
                base.Locale = table.Locale;
            }
            if (table.Namespace != table.DataSet.Namespace)
            {
                base.Namespace = table.Namespace;
            }
            base.Prefix = table.Prefix;
            base.MinimumCapacity = table.MinimumCapacity;
        }

        [DebuggerNonUserCode]
        protected ActionTypesDataTable(SerializationInfo info, StreamingContext context) : base(info, context)
        {
            this.InitVars();
        }

        [DebuggerNonUserCode]
        public void AddActionTypesRow(ThemeDataset.ActionTypesRow row)
        {
            base.Rows.Add(row);
        }

        [DebuggerNonUserCode]
        public ThemeDataset.ActionTypesRow AddActionTypesRow(int ActionTypeID, string Name, bool PseudoAction)
        {
            ThemeDataset.ActionTypesRow row = (ThemeDataset.ActionTypesRow) base.NewRow();
            row.ItemArray = new object[] { ActionTypeID, Name, PseudoAction };
            base.Rows.Add(row);
            return row;
        }

        [DebuggerNonUserCode]
        public override DataTable Clone()
        {
            ThemeDataset.ActionTypesDataTable table = (ThemeDataset.ActionTypesDataTable) base.Clone();
            table.InitVars();
            return table;
        }

        [DebuggerNonUserCode]
        protected override DataTable CreateInstance()
        {
            return new ThemeDataset.ActionTypesDataTable();
        }

        [DebuggerNonUserCode]
        public ThemeDataset.ActionTypesRow FindByActionTypeID(int ActionTypeID)
        {
            return (ThemeDataset.ActionTypesRow) base.Rows.Find(new object[] { ActionTypeID });
        }

        [DebuggerNonUserCode]
        public virtual IEnumerator GetEnumerator()
        {
            return base.Rows.GetEnumerator();
        }

        [DebuggerNonUserCode]
        protected override Type GetRowType()
        {
            return typeof(ThemeDataset.ActionTypesRow);
        }

        [DebuggerNonUserCode]
        public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs)
        {
            XmlSchemaComplexType type = new XmlSchemaComplexType();
            XmlSchemaSequence sequence = new XmlSchemaSequence();
            ThemeDataset dataset = new ThemeDataset();
            XmlSchemaAny item = new XmlSchemaAny();
            item.Namespace = "http://www.w3.org/2001/XMLSchema";
            item.MinOccurs = 0M;
            item.MaxOccurs = 79228162514264337593543950335M;
            item.ProcessContents = XmlSchemaContentProcessing.Lax;
            sequence.Items.Add(item);
            XmlSchemaAny any2 = new XmlSchemaAny();
            any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
            any2.MinOccurs = 1M;
            any2.ProcessContents = XmlSchemaContentProcessing.Lax;
            sequence.Items.Add(any2);
            XmlSchemaAttribute attribute = new XmlSchemaAttribute();
            attribute.Name = "namespace";
            attribute.FixedValue = dataset.Namespace;
            type.Attributes.Add(attribute);
            XmlSchemaAttribute attribute2 = new XmlSchemaAttribute();
            attribute2.Name = "tableTypeName";
            attribute2.FixedValue = "ActionTypesDataTable";
            type.Attributes.Add(attribute2);
            type.Particle = sequence;
            XmlSchema schemaSerializable = dataset.GetSchemaSerializable();
            if (xs.Contains(schemaSerializable.TargetNamespace))
            {
                MemoryStream stream = new MemoryStream();
                MemoryStream stream2 = new MemoryStream();
                try
                {
                    XmlSchema current = null;
                    schemaSerializable.Write(stream);
                    IEnumerator enumerator = xs.Schemas(schemaSerializable.TargetNamespace).GetEnumerator();
                    while (enumerator.MoveNext())
                    {
                        current = (XmlSchema) enumerator.Current;
                        stream2.SetLength(0L);
                        current.Write(stream2);
                        if (stream.Length == stream2.Length)
                        {
                            stream.Position = 0L;
                            stream2.Position = 0L;
                            while ((stream.Position != stream.Length) && (stream.ReadByte() == stream2.ReadByte()))
                            {
                            }
                            if (stream.Position == stream.Length)
                            {
                                return type;
                            }
                        }
                    }
                }
                finally
                {
                    if (stream != null)
                    {
                        stream.Close();
                    }
                    if (stream2 != null)
                    {
                        stream2.Close();
                    }
                }
            }
            xs.Add(schemaSerializable);
            return type;
        }

        [DebuggerNonUserCode]
        private void InitClass()
        {
            this.columnActionTypeID = new DataColumn("ActionTypeID", typeof(int), null, MappingType.Element);
            base.Columns.Add(this.columnActionTypeID);
            this.columnName = new DataColumn("Name", typeof(string), null, MappingType.Element);
            base.Columns.Add(this.columnName);
            this.columnPseudoAction = new DataColumn("PseudoAction", typeof(bool), null, MappingType.Element);
            base.Columns.Add(this.columnPseudoAction);
            base.Constraints.Add(new UniqueConstraint("Constraint1", new DataColumn[] { this.columnActionTypeID }, true));
            this.columnActionTypeID.AllowDBNull = false;
            this.columnActionTypeID.Unique = true;
            this.columnName.AllowDBNull = false;
            this.columnName.MaxLength = 20;
            this.columnPseudoAction.AllowDBNull = false;
        }

        [DebuggerNonUserCode]
        internal void InitVars()
        {
            this.columnActionTypeID = base.Columns["ActionTypeID"];
            this.columnName = base.Columns["Name"];
            this.columnPseudoAction = base.Columns["PseudoAction"];
        }

        [DebuggerNonUserCode]
        public ThemeDataset.ActionTypesRow NewActionTypesRow()
        {
            return (ThemeDataset.ActionTypesRow) base.NewRow();
        }

        [DebuggerNonUserCode]
        protected override DataRow NewRowFromBuilder(DataRowBuilder builder)
        {
            return new ThemeDataset.ActionTypesRow(builder);
        }

        [DebuggerNonUserCode]
        protected override void OnRowChanged(DataRowChangeEventArgs e)
        {
            base.OnRowChanged(e);
            if (this.ActionTypesRowChanged != null)
            {
                this.ActionTypesRowChanged(this, new ThemeDataset.ActionTypesRowChangeEvent((ThemeDataset.ActionTypesRow) e.Row, e.Action));
            }
        }

        [DebuggerNonUserCode]
        protected override void OnRowChanging(DataRowChangeEventArgs e)
        {
            base.OnRowChanging(e);
            if (this.ActionTypesRowChanging != null)
            {
                this.ActionTypesRowChanging(this, new ThemeDataset.ActionTypesRowChangeEvent((ThemeDataset.ActionTypesRow) e.Row, e.Action));
            }
        }

        [DebuggerNonUserCode]
        protected override void OnRowDeleted(DataRowChangeEventArgs e)
        {
            base.OnRowDeleted(e);
            if (this.ActionTypesRowDeleted != null)
            {
                this.ActionTypesRowDeleted(this, new ThemeDataset.ActionTypesRowChangeEvent((ThemeDataset.ActionTypesRow) e.Row, e.Action));
            }
        }

        [DebuggerNonUserCode]
        protected override void OnRowDeleting(DataRowChangeEventArgs e)
        {
            base.OnRowDeleting(e);
            if (this.ActionTypesRowDeleting != null)
            {
                this.ActionTypesRowDeleting(this, new ThemeDataset.ActionTypesRowChangeEvent((ThemeDataset.ActionTypesRow) e.Row, e.Action));
            }
        }

        [DebuggerNonUserCode]
        public void RemoveActionTypesRow(ThemeDataset.ActionTypesRow row)
        {
            base.Rows.Remove(row);
        }

        // Properties
        [DebuggerNonUserCode]
        public DataColumn ActionTypeIDColumn
        {
            get
            {
                return this.columnActionTypeID;
            }
        }

        [Browsable(false), DebuggerNonUserCode]
        public int Count
        {
            get
            {
                return base.Rows.Count;
            }
        }

        [DebuggerNonUserCode]
        public ThemeDataset.ActionTypesRow this[int index]
        {
            get
            {
                return (ThemeDataset.ActionTypesRow) base.Rows[index];
            }
        }

        [DebuggerNonUserCode]
        public DataColumn NameColumn
        {
            get
            {
                return this.columnName;
            }
        }

        [DebuggerNonUserCode]
        public DataColumn PseudoActionColumn
        {
            get
            {
                return this.columnPseudoAction;
            }
        }
    }

    [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
    public class ActionTypesRow : DataRow
    {
        // Fields
        private ThemeDataset.ActionTypesDataTable tableActionTypes;

        // Methods
        [DebuggerNonUserCode]
        internal ActionTypesRow(DataRowBuilder rb) : base(rb)
        {
            this.tableActionTypes = (ThemeDataset.ActionTypesDataTable) base.Table;
        }

        [DebuggerNonUserCode]
        public ThemeDataset.ActionsRow[] GetActionsRows()
        {
            if (base.Table.ChildRelations["Actions_ActionTypes"] == null)
            {
                return new ThemeDataset.ActionsRow[0];
            }
            return (ThemeDataset.ActionsRow[]) base.GetChildRows(base.Table.ChildRelations["Actions_ActionTypes"]);
        }

        [DebuggerNonUserCode]
        public ThemeDataset.PseudoActionVisualizationRow[] GetPseudoActionVisualizationRows()
        {
            if (base.Table.ChildRelations["PseudoActionVisualization_ActionTypes"] == null)
            {
                return new ThemeDataset.PseudoActionVisualizationRow[0];
            }
            return (ThemeDataset.PseudoActionVisualizationRow[]) base.GetChildRows(base.Table.ChildRelations["PseudoActionVisualization_ActionTypes"]);
        }

        // Properties
        [DebuggerNonUserCode]
        public int ActionTypeID
        {
            get
            {
                return (int) base[this.tableActionTypes.ActionTypeIDColumn];
            }
            set
            {
                base[this.tableActionTypes.ActionTypeIDColumn] = value;
            }
        }

        [DebuggerNonUserCode]
        public string Name
        {
            get
            {
                return (string) base[this.tableActionTypes.NameColumn];
            }
            set
            {
                base[this.tableActionTypes.NameColumn] = value;
            }
        }

        [DebuggerNonUserCode]
        public bool PseudoAction
        {
            get
            {
                return (bool) base[this.tableActionTypes.PseudoActionColumn];
            }
            set
            {
                base[this.tableActionTypes.PseudoActionColumn] = value;
            }
        }
    }

    [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
    public class ActionTypesRowChangeEvent : EventArgs
    {
        // Fields
        private DataRowAction eventAction;
        private ThemeDataset.ActionTypesRow eventRow;

        // Methods
        [DebuggerNonUserCode]
        public ActionTypesRowChangeEvent(ThemeDataset.ActionTypesRow row, DataRowAction action)
        {
            this.eventRow = row;
            this.eventAction = action;
        }

        // Properties
        [DebuggerNonUserCode]
        public DataRowAction Action
        {
            get
            {
                return this.eventAction;
            }
        }

        [DebuggerNonUserCode]
        public ThemeDataset.ActionTypesRow Row
        {
            get
            {
                return this.eventRow;
            }
        }
    }

    public delegate void ActionTypesRowChangeEventHandler(object sender, ThemeDataset.ActionTypesRowChangeEvent e);

    [Serializable, XmlSchemaProvider("GetTypedTableSchema"), GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
    public class GroupsDataTable : DataTable, IEnumerable
    {
        // Fields
        private DataColumn columnGroupID;
        private DataColumn columnName;

        // Events
        public event ThemeDataset.GroupsRowChangeEventHandler GroupsRowChanged;

        public event ThemeDataset.GroupsRowChangeEventHandler GroupsRowChanging;

        public event ThemeDataset.GroupsRowChangeEventHandler GroupsRowDeleted;

        public event ThemeDataset.GroupsRowChangeEventHandler GroupsRowDeleting;

        // Methods
        [DebuggerNonUserCode]
        public GroupsDataTable()
        {
            base.TableName = "Groups";
            this.BeginInit();
            this.InitClass();
            this.EndInit();
        }

        [DebuggerNonUserCode]
        internal GroupsDataTable(DataTable table)
        {
            base.TableName = table.TableName;
            if (table.CaseSensitive != table.DataSet.CaseSensitive)
            {
                base.CaseSensitive = table.CaseSensitive;
            }
            if (table.Locale.ToString() != table.DataSet.Locale.ToString())
            {
                base.Locale = table.Locale;
            }
            if (table.Namespace != table.DataSet.Namespace)
            {
                base.Namespace = table.Namespace;
            }
            base.Prefix = table.Prefix;
            base.MinimumCapacity = table.MinimumCapacity;
        }

        [DebuggerNonUserCode]
        protected GroupsDataTable(SerializationInfo info, StreamingContext context) : base(info, context)
        {
            this.InitVars();
        }

        [DebuggerNonUserCode]
        public void AddGroupsRow(ThemeDataset.GroupsRow row)
        {
            base.Rows.Add(row);
        }

        [DebuggerNonUserCode]
        public ThemeDataset.GroupsRow AddGroupsRow(int GroupID, string Name)
        {
            ThemeDataset.GroupsRow row = (ThemeDataset.GroupsRow) base.NewRow();
            row.ItemArray = new object[] { GroupID, Name };
            base.Rows.Add(row);
            return row;
        }

        [DebuggerNonUserCode]
        public override DataTable Clone()
        {
            ThemeDataset.GroupsDataTable table = (ThemeDataset.GroupsDataTable) base.Clone();
            table.InitVars();
            return table;
        }

        [DebuggerNonUserCode]
        protected override DataTable CreateInstance()
        {
            return new ThemeDataset.GroupsDataTable();
        }

        [DebuggerNonUserCode]
        public ThemeDataset.GroupsRow FindByGroupID(int GroupID)
        {
            return (ThemeDataset.GroupsRow) base.Rows.Find(new object[] { GroupID });
        }

        [DebuggerNonUserCode]
        public virtual IEnumerator GetEnumerator()
        {
            return base.Rows.GetEnumerator();
        }

        [DebuggerNonUserCode]
        protected override Type GetRowType()
        {
            return typeof(ThemeDataset.GroupsRow);
        }

        [DebuggerNonUserCode]
        public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs)
        {
            XmlSchemaComplexType type = new XmlSchemaComplexType();
            XmlSchemaSequence sequence = new XmlSchemaSequence();
            ThemeDataset dataset = new ThemeDataset();
            XmlSchemaAny item = new XmlSchemaAny();
            item.Namespace = "http://www.w3.org/2001/XMLSchema";
            item.MinOccurs = 0M;
            item.MaxOccurs = 79228162514264337593543950335M;
            item.ProcessContents = XmlSchemaContentProcessing.Lax;
            sequence.Items.Add(item);
            XmlSchemaAny any2 = new XmlSchemaAny();
            any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
            any2.MinOccurs = 1M;
            any2.ProcessContents = XmlSchemaContentProcessing.Lax;
            sequence.Items.Add(any2);
            XmlSchemaAttribute attribute = new XmlSchemaAttribute();
            attribute.Name = "namespace";
            attribute.FixedValue = dataset.Namespace;
            type.Attributes.Add(attribute);
            XmlSchemaAttribute attribute2 = new XmlSchemaAttribute();
            attribute2.Name = "tableTypeName";
            attribute2.FixedValue = "GroupsDataTable";
            type.Attributes.Add(attribute2);
            type.Particle = sequence;
            XmlSchema schemaSerializable = dataset.GetSchemaSerializable();
            if (xs.Contains(schemaSerializable.TargetNamespace))
            {
                MemoryStream stream = new MemoryStream();
                MemoryStream stream2 = new MemoryStream();
                try
                {
                    XmlSchema current = null;
                    schemaSerializable.Write(stream);
                    IEnumerator enumerator = xs.Schemas(schemaSerializable.TargetNamespace).GetEnumerator();
                    while (enumerator.MoveNext())
                    {
                        current = (XmlSchema) enumerator.Current;
                        stream2.SetLength(0L);
                        current.Write(stream2);
                        if (stream.Length == stream2.Length)
                        {
                            stream.Position = 0L;
                            stream2.Position = 0L;
                            while ((stream.Position != stream.Length) && (stream.ReadByte() == stream2.ReadByte()))
                            {
                            }
                            if (stream.Position == stream.Length)
                            {
                                return type;
                            }
                        }
                    }
                }
                finally
                {
                    if (stream != null)
                    {
                        stream.Close();
                    }
                    if (stream2 != null)
                    {
                        stream2.Close();
                    }
                }
            }
            xs.Add(schemaSerializable);
            return type;
        }

        [DebuggerNonUserCode]
        private void InitClass()
        {
            this.columnGroupID = new DataColumn("GroupID", typeof(int), null, MappingType.Element);
            base.Columns.Add(this.columnGroupID);
            this.columnName = new DataColumn("Name", typeof(string), null, MappingType.Element);
            base.Columns.Add(this.columnName);
            base.Constraints.Add(new UniqueConstraint("Constraint1", new DataColumn[] { this.columnGroupID }, true));
            this.columnGroupID.AllowDBNull = false;
            this.columnGroupID.Unique = true;
            this.columnName.AllowDBNull = false;
            this.columnName.MaxLength = 20;
        }

        [DebuggerNonUserCode]
        internal void InitVars()
        {
            this.columnGroupID = base.Columns["GroupID"];
            this.columnName = base.Columns["Name"];
        }

        [DebuggerNonUserCode]
        public ThemeDataset.GroupsRow NewGroupsRow()
        {
            return (ThemeDataset.GroupsRow) base.NewRow();
        }

        [DebuggerNonUserCode]
        protected override DataRow NewRowFromBuilder(DataRowBuilder builder)
        {
            return new ThemeDataset.GroupsRow(builder);
        }

        [DebuggerNonUserCode]
        protected override void OnRowChanged(DataRowChangeEventArgs e)
        {
            base.OnRowChanged(e);
            if (this.GroupsRowChanged != null)
            {
                this.GroupsRowChanged(this, new ThemeDataset.GroupsRowChangeEvent((ThemeDataset.GroupsRow) e.Row, e.Action));
            }
        }

        [DebuggerNonUserCode]
        protected override void OnRowChanging(DataRowChangeEventArgs e)
        {
            base.OnRowChanging(e);
            if (this.GroupsRowChanging != null)
            {
                this.GroupsRowChanging(this, new ThemeDataset.GroupsRowChangeEvent((ThemeDataset.GroupsRow) e.Row, e.Action));
            }
        }

        [DebuggerNonUserCode]
        protected override void OnRowDeleted(DataRowChangeEventArgs e)
        {
            base.OnRowDeleted(e);
            if (this.GroupsRowDeleted != null)
            {
                this.GroupsRowDeleted(this, new ThemeDataset.GroupsRowChangeEvent((ThemeDataset.GroupsRow) e.Row, e.Action));
            }
        }

        [DebuggerNonUserCode]
        protected override void OnRowDeleting(DataRowChangeEventArgs e)
        {
            base.OnRowDeleting(e);
            if (this.GroupsRowDeleting != null)
            {
                this.GroupsRowDeleting(this, new ThemeDataset.GroupsRowChangeEvent((ThemeDataset.GroupsRow) e.Row, e.Action));
            }
        }

        [DebuggerNonUserCode]
        public void RemoveGroupsRow(ThemeDataset.GroupsRow row)
        {
            base.Rows.Remove(row);
        }

        // Properties
        [DebuggerNonUserCode, Browsable(false)]
        public int Count
        {
            get
            {
                return base.Rows.Count;
            }
        }

        [DebuggerNonUserCode]
        public DataColumn GroupIDColumn
        {
            get
            {
                return this.columnGroupID;
            }
        }

        [DebuggerNonUserCode]
        public ThemeDataset.GroupsRow this[int index]
        {
            get
            {
                return (ThemeDataset.GroupsRow) base.Rows[index];
            }
        }

        [DebuggerNonUserCode]
        public DataColumn NameColumn
        {
            get
            {
                return this.columnName;
            }
        }
    }

    [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
    public class GroupsRow : DataRow
    {
        // Fields
        private ThemeDataset.GroupsDataTable tableGroups;

        // Methods
        [DebuggerNonUserCode]
        internal GroupsRow(DataRowBuilder rb) : base(rb)
        {
            this.tableGroups = (ThemeDataset.GroupsDataTable) base.Table;
        }

        [DebuggerNonUserCode]
        public ThemeDataset.LedsRow[] GetLedsRows()
        {
            if (base.Table.ChildRelations["Leds_Groups"] == null)
            {
                return new ThemeDataset.LedsRow[0];
            }
            return (ThemeDataset.LedsRow[]) base.GetChildRows(base.Table.ChildRelations["Leds_Groups"]);
        }

        [DebuggerNonUserCode]
        public ThemeDataset.ZonesGroupsRow[] GetZonesGroupsRows()
        {
            if (base.Table.ChildRelations["ZonesGroups_Groups"] == null)
            {
                return new ThemeDataset.ZonesGroupsRow[0];
            }
            return (ThemeDataset.ZonesGroupsRow[]) base.GetChildRows(base.Table.ChildRelations["ZonesGroups_Groups"]);
        }

        // Properties
        [DebuggerNonUserCode]
        public int GroupID
        {
            get
            {
                return (int) base[this.tableGroups.GroupIDColumn];
            }
            set
            {
                base[this.tableGroups.GroupIDColumn] = value;
            }
        }

        [DebuggerNonUserCode]
        public string Name
        {
            get
            {
                return (string) base[this.tableGroups.NameColumn];
            }
            set
            {
                base[this.tableGroups.NameColumn] = value;
            }
        }
    }

    [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
    public class GroupsRowChangeEvent : EventArgs
    {
        // Fields
        private DataRowAction eventAction;
        private ThemeDataset.GroupsRow eventRow;

        // Methods
        [DebuggerNonUserCode]
        public GroupsRowChangeEvent(ThemeDataset.GroupsRow row, DataRowAction action)
        {
            this.eventRow = row;
            this.eventAction = action;
        }

        // Properties
        [DebuggerNonUserCode]
        public DataRowAction Action
        {
            get
            {
                return this.eventAction;
            }
        }

        [DebuggerNonUserCode]
        public ThemeDataset.GroupsRow Row
        {
            get
            {
                return this.eventRow;
            }
        }
    }

    public delegate void GroupsRowChangeEventHandler(object sender, ThemeDataset.GroupsRowChangeEvent e);

    [Serializable, GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0"), XmlSchemaProvider("GetTypedTableSchema")]
    public class LedsDataTable : DataTable, IEnumerable
    {
        // Fields
        private DataColumn columnDescription;
        private DataColumn columnGroupID;
        private DataColumn columnLedID;
        private DataColumn columnName;

        // Events
        public event ThemeDataset.LedsRowChangeEventHandler LedsRowChanged;

        public event ThemeDataset.LedsRowChangeEventHandler LedsRowChanging;

        public event ThemeDataset.LedsRowChangeEventHandler LedsRowDeleted;

        public event ThemeDataset.LedsRowChangeEventHandler LedsRowDeleting;

        // Methods
        [DebuggerNonUserCode]
        public LedsDataTable()
        {
            base.TableName = "Leds";
            this.BeginInit();
            this.InitClass();
            this.EndInit();
        }

        [DebuggerNonUserCode]
        internal LedsDataTable(DataTable table)
        {
            base.TableName = table.TableName;
            if (table.CaseSensitive != table.DataSet.CaseSensitive)
            {
                base.CaseSensitive = table.CaseSensitive;
            }
            if (table.Locale.ToString() != table.DataSet.Locale.ToString())
            {
                base.Locale = table.Locale;
            }
            if (table.Namespace != table.DataSet.Namespace)
            {
                base.Namespace = table.Namespace;
            }
            base.Prefix = table.Prefix;
            base.MinimumCapacity = table.MinimumCapacity;
        }

        [DebuggerNonUserCode]
        protected LedsDataTable(SerializationInfo info, StreamingContext context) : base(info, context)
        {
            this.InitVars();
        }

        [DebuggerNonUserCode]
        public void AddLedsRow(ThemeDataset.LedsRow row)
        {
            base.Rows.Add(row);
        }

        [DebuggerNonUserCode]
        public ThemeDataset.LedsRow AddLedsRow(int LedID, string Name, string Description, ThemeDataset.GroupsRow parentGroupsRowByLeds_Groups)
        {
            ThemeDataset.LedsRow row = (ThemeDataset.LedsRow) base.NewRow();
            object[] objArray2 = new object[4];
            objArray2[0] = LedID;
            objArray2[1] = Name;
            objArray2[2] = Description;
            object[] objArray = objArray2;
            if (parentGroupsRowByLeds_Groups != null)
            {
                objArray[3] = parentGroupsRowByLeds_Groups[0];
            }
            row.ItemArray = objArray;
            base.Rows.Add(row);
            return row;
        }

        [DebuggerNonUserCode]
        public override DataTable Clone()
        {
            ThemeDataset.LedsDataTable table = (ThemeDataset.LedsDataTable) base.Clone();
            table.InitVars();
            return table;
        }

        [DebuggerNonUserCode]
        protected override DataTable CreateInstance()
        {
            return new ThemeDataset.LedsDataTable();
        }

        [DebuggerNonUserCode]
        public ThemeDataset.LedsRow FindByLedID(int LedID)
        {
            return (ThemeDataset.LedsRow) base.Rows.Find(new object[] { LedID });
        }

        [DebuggerNonUserCode]
        public virtual IEnumerator GetEnumerator()
        {
            return base.Rows.GetEnumerator();
        }

        [DebuggerNonUserCode]
        protected override Type GetRowType()
        {
            return typeof(ThemeDataset.LedsRow);
        }

        [DebuggerNonUserCode]
        public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs)
        {
            XmlSchemaComplexType type = new XmlSchemaComplexType();
            XmlSchemaSequence sequence = new XmlSchemaSequence();
            ThemeDataset dataset = new ThemeDataset();
            XmlSchemaAny item = new XmlSchemaAny();
            item.Namespace = "http://www.w3.org/2001/XMLSchema";
            item.MinOccurs = 0M;
            item.MaxOccurs = 79228162514264337593543950335M;
            item.ProcessContents = XmlSchemaContentProcessing.Lax;
            sequence.Items.Add(item);
            XmlSchemaAny any2 = new XmlSchemaAny();
            any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
            any2.MinOccurs = 1M;
            any2.ProcessContents = XmlSchemaContentProcessing.Lax;
            sequence.Items.Add(any2);
            XmlSchemaAttribute attribute = new XmlSchemaAttribute();
            attribute.Name = "namespace";
            attribute.FixedValue = dataset.Namespace;
            type.Attributes.Add(attribute);
            XmlSchemaAttribute attribute2 = new XmlSchemaAttribute();
            attribute2.Name = "tableTypeName";
            attribute2.FixedValue = "LedsDataTable";
            type.Attributes.Add(attribute2);
            type.Particle = sequence;
            XmlSchema schemaSerializable = dataset.GetSchemaSerializable();
            if (xs.Contains(schemaSerializable.TargetNamespace))
            {
                MemoryStream stream = new MemoryStream();
                MemoryStream stream2 = new MemoryStream();
                try
                {
                    XmlSchema current = null;
                    schemaSerializable.Write(stream);
                    IEnumerator enumerator = xs.Schemas(schemaSerializable.TargetNamespace).GetEnumerator();
                    while (enumerator.MoveNext())
                    {
                        current = (XmlSchema) enumerator.Current;
                        stream2.SetLength(0L);
                        current.Write(stream2);
                        if (stream.Length == stream2.Length)
                        {
                            stream.Position = 0L;
                            stream2.Position = 0L;
                            while ((stream.Position != stream.Length) && (stream.ReadByte() == stream2.ReadByte()))
                            {
                            }
                            if (stream.Position == stream.Length)
                            {
                                return type;
                            }
                        }
                    }
                }
                finally
                {
                    if (stream != null)
                    {
                        stream.Close();
                    }
                    if (stream2 != null)
                    {
                        stream2.Close();
                    }
                }
            }
            xs.Add(schemaSerializable);
            return type;
        }

        [DebuggerNonUserCode]
        private void InitClass()
        {
            this.columnLedID = new DataColumn("LedID", typeof(int), null, MappingType.Element);
            base.Columns.Add(this.columnLedID);
            this.columnName = new DataColumn("Name", typeof(string), null, MappingType.Element);
            base.Columns.Add(this.columnName);
            this.columnDescription = new DataColumn("Description", typeof(string), null, MappingType.Element);
            base.Columns.Add(this.columnDescription);
            this.columnGroupID = new DataColumn("GroupID", typeof(int), null, MappingType.Element);
            base.Columns.Add(this.columnGroupID);
            base.Constraints.Add(new UniqueConstraint("Constraint1", new DataColumn[] { this.columnLedID }, true));
            this.columnLedID.AllowDBNull = false;
            this.columnLedID.Unique = true;
            this.columnName.AllowDBNull = false;
            this.columnName.MaxLength = 20;
            this.columnDescription.AllowDBNull = false;
            this.columnDescription.MaxLength = 50;
        }

        [DebuggerNonUserCode]
        internal void InitVars()
        {
            this.columnLedID = base.Columns["LedID"];
            this.columnName = base.Columns["Name"];
            this.columnDescription = base.Columns["Description"];
            this.columnGroupID = base.Columns["GroupID"];
        }

        [DebuggerNonUserCode]
        public ThemeDataset.LedsRow NewLedsRow()
        {
            return (ThemeDataset.LedsRow) base.NewRow();
        }

        [DebuggerNonUserCode]
        protected override DataRow NewRowFromBuilder(DataRowBuilder builder)
        {
            return new ThemeDataset.LedsRow(builder);
        }

        [DebuggerNonUserCode]
        protected override void OnRowChanged(DataRowChangeEventArgs e)
        {
            base.OnRowChanged(e);
            if (this.LedsRowChanged != null)
            {
                this.LedsRowChanged(this, new ThemeDataset.LedsRowChangeEvent((ThemeDataset.LedsRow) e.Row, e.Action));
            }
        }

        [DebuggerNonUserCode]
        protected override void OnRowChanging(DataRowChangeEventArgs e)
        {
            base.OnRowChanging(e);
            if (this.LedsRowChanging != null)
            {
                this.LedsRowChanging(this, new ThemeDataset.LedsRowChangeEvent((ThemeDataset.LedsRow) e.Row, e.Action));
            }
        }

        [DebuggerNonUserCode]
        protected override void OnRowDeleted(DataRowChangeEventArgs e)
        {
            base.OnRowDeleted(e);
            if (this.LedsRowDeleted != null)
            {
                this.LedsRowDeleted(this, new ThemeDataset.LedsRowChangeEvent((ThemeDataset.LedsRow) e.Row, e.Action));
            }
        }

        [DebuggerNonUserCode]
        protected override void OnRowDeleting(DataRowChangeEventArgs e)
        {
            base.OnRowDeleting(e);
            if (this.LedsRowDeleting != null)
            {
                this.LedsRowDeleting(this, new ThemeDataset.LedsRowChangeEvent((ThemeDataset.LedsRow) e.Row, e.Action));
            }
        }

        [DebuggerNonUserCode]
        public void RemoveLedsRow(ThemeDataset.LedsRow row)
        {
            base.Rows.Remove(row);
        }

        // Properties
        [Browsable(false), DebuggerNonUserCode]
        public int Count
        {
            get
            {
                return base.Rows.Count;
            }
        }

        [DebuggerNonUserCode]
        public DataColumn DescriptionColumn
        {
            get
            {
                return this.columnDescription;
            }
        }

        [DebuggerNonUserCode]
        public DataColumn GroupIDColumn
        {
            get
            {
                return this.columnGroupID;
            }
        }

        [DebuggerNonUserCode]
        public ThemeDataset.LedsRow this[int index]
        {
            get
            {
                return (ThemeDataset.LedsRow) base.Rows[index];
            }
        }

        [DebuggerNonUserCode]
        public DataColumn LedIDColumn
        {
            get
            {
                return this.columnLedID;
            }
        }

        [DebuggerNonUserCode]
        public DataColumn NameColumn
        {
            get
            {
                return this.columnName;
            }
        }
    }

    [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
    public class LedsRow : DataRow
    {
        // Fields
        private ThemeDataset.LedsDataTable tableLeds;

        // Methods
        [DebuggerNonUserCode]
        internal LedsRow(DataRowBuilder rb) : base(rb)
        {
            this.tableLeds = (ThemeDataset.LedsDataTable) base.Table;
        }

        [DebuggerNonUserCode]
        public bool IsGroupIDNull()
        {
            return base.IsNull(this.tableLeds.GroupIDColumn);
        }

        [DebuggerNonUserCode]
        public void SetGroupIDNull()
        {
            base[this.tableLeds.GroupIDColumn] = Convert.DBNull;
        }

        // Properties
        [DebuggerNonUserCode]
        public string Description
        {
            get
            {
                return (string) base[this.tableLeds.DescriptionColumn];
            }
            set
            {
                base[this.tableLeds.DescriptionColumn] = value;
            }
        }

        [DebuggerNonUserCode]
        public int GroupID
        {
            get
            {
                int num;
                try
                {
                    num = (int) base[this.tableLeds.GroupIDColumn];
                }
                catch (InvalidCastException exception)
                {
                    throw new StrongTypingException("The value for column 'GroupID' in table 'Leds' is DBNull.", exception);
                }
                return num;
            }
            set
            {
                base[this.tableLeds.GroupIDColumn] = value;
            }
        }

        [DebuggerNonUserCode]
        public ThemeDataset.GroupsRow GroupsRow
        {
            get
            {
                return (ThemeDataset.GroupsRow) base.GetParentRow(base.Table.ParentRelations["Leds_Groups"]);
            }
            set
            {
                base.SetParentRow(value, base.Table.ParentRelations["Leds_Groups"]);
            }
        }

        [DebuggerNonUserCode]
        public int LedID
        {
            get
            {
                return (int) base[this.tableLeds.LedIDColumn];
            }
            set
            {
                base[this.tableLeds.LedIDColumn] = value;
            }
        }

        [DebuggerNonUserCode]
        public string Name
        {
            get
            {
                return (string) base[this.tableLeds.NameColumn];
            }
            set
            {
                base[this.tableLeds.NameColumn] = value;
            }
        }
    }

    [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
    public class LedsRowChangeEvent : EventArgs
    {
        // Fields
        private DataRowAction eventAction;
        private ThemeDataset.LedsRow eventRow;

        // Methods
        [DebuggerNonUserCode]
        public LedsRowChangeEvent(ThemeDataset.LedsRow row, DataRowAction action)
        {
            this.eventRow = row;
            this.eventAction = action;
        }

        // Properties
        [DebuggerNonUserCode]
        public DataRowAction Action
        {
            get
            {
                return this.eventAction;
            }
        }

        [DebuggerNonUserCode]
        public ThemeDataset.LedsRow Row
        {
            get
            {
                return this.eventRow;
            }
        }
    }

    public delegate void LedsRowChangeEventHandler(object sender, ThemeDataset.LedsRowChangeEvent e);

    [Serializable, XmlSchemaProvider("GetTypedTableSchema"), GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
    public class PseudoActionVisualizationDataTable : DataTable, IEnumerable
    {
        // Fields
        private DataColumn columnActionTypeID;
        private DataColumn columnVisualizationID;

        // Events
        public event ThemeDataset.PseudoActionVisualizationRowChangeEventHandler PseudoActionVisualizationRowChanged;

        public event ThemeDataset.PseudoActionVisualizationRowChangeEventHandler PseudoActionVisualizationRowChanging;

        public event ThemeDataset.PseudoActionVisualizationRowChangeEventHandler PseudoActionVisualizationRowDeleted;

        public event ThemeDataset.PseudoActionVisualizationRowChangeEventHandler PseudoActionVisualizationRowDeleting;

        // Methods
        [DebuggerNonUserCode]
        public PseudoActionVisualizationDataTable()
        {
            base.TableName = "PseudoActionVisualization";
            this.BeginInit();
            this.InitClass();
            this.EndInit();
        }

        [DebuggerNonUserCode]
        internal PseudoActionVisualizationDataTable(DataTable table)
        {
            base.TableName = table.TableName;
            if (table.CaseSensitive != table.DataSet.CaseSensitive)
            {
                base.CaseSensitive = table.CaseSensitive;
            }
            if (table.Locale.ToString() != table.DataSet.Locale.ToString())
            {
                base.Locale = table.Locale;
            }
            if (table.Namespace != table.DataSet.Namespace)
            {
                base.Namespace = table.Namespace;
            }
            base.Prefix = table.Prefix;
            base.MinimumCapacity = table.MinimumCapacity;
        }

        [DebuggerNonUserCode]
        protected PseudoActionVisualizationDataTable(SerializationInfo info, StreamingContext context) : base(info, context)
        {
            this.InitVars();
        }

        [DebuggerNonUserCode]
        public void AddPseudoActionVisualizationRow(ThemeDataset.PseudoActionVisualizationRow row)
        {
            base.Rows.Add(row);
        }

        [DebuggerNonUserCode]
        public ThemeDataset.PseudoActionVisualizationRow AddPseudoActionVisualizationRow(ThemeDataset.ActionTypesRow parentActionTypesRowByPseudoActionVisualization_ActionTypes, ThemeDataset.VisualizationsRow parentVisualizationsRowByPseudoActionVisualization_Visualizations)
        {
            ThemeDataset.PseudoActionVisualizationRow row = (ThemeDataset.PseudoActionVisualizationRow) base.NewRow();
            object[] objArray = new object[2];
            if (parentActionTypesRowByPseudoActionVisualization_ActionTypes != null)
            {
                objArray[0] = parentActionTypesRowByPseudoActionVisualization_ActionTypes[0];
            }
            if (parentVisualizationsRowByPseudoActionVisualization_Visualizations != null)
            {
                objArray[1] = parentVisualizationsRowByPseudoActionVisualization_Visualizations[0];
            }
            row.ItemArray = objArray;
            base.Rows.Add(row);
            return row;
        }

        [DebuggerNonUserCode]
        public override DataTable Clone()
        {
            ThemeDataset.PseudoActionVisualizationDataTable table = (ThemeDataset.PseudoActionVisualizationDataTable) base.Clone();
            table.InitVars();
            return table;
        }

        [DebuggerNonUserCode]
        protected override DataTable CreateInstance()
        {
            return new ThemeDataset.PseudoActionVisualizationDataTable();
        }

        [DebuggerNonUserCode]
        public ThemeDataset.PseudoActionVisualizationRow FindByActionTypeIDVisualizationID(int ActionTypeID, int VisualizationID)
        {
            return (ThemeDataset.PseudoActionVisualizationRow) base.Rows.Find(new object[] { ActionTypeID, VisualizationID });
        }

        [DebuggerNonUserCode]
        public virtual IEnumerator GetEnumerator()
        {
            return base.Rows.GetEnumerator();
        }

        [DebuggerNonUserCode]
        protected override Type GetRowType()
        {
            return typeof(ThemeDataset.PseudoActionVisualizationRow);
        }

        [DebuggerNonUserCode]
        public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs)
        {
            XmlSchemaComplexType type = new XmlSchemaComplexType();
            XmlSchemaSequence sequence = new XmlSchemaSequence();
            ThemeDataset dataset = new ThemeDataset();
            XmlSchemaAny item = new XmlSchemaAny();
            item.Namespace = "http://www.w3.org/2001/XMLSchema";
            item.MinOccurs = 0M;
            item.MaxOccurs = 79228162514264337593543950335M;
            item.ProcessContents = XmlSchemaContentProcessing.Lax;
            sequence.Items.Add(item);
            XmlSchemaAny any2 = new XmlSchemaAny();
            any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
            any2.MinOccurs = 1M;
            any2.ProcessContents = XmlSchemaContentProcessing.Lax;
            sequence.Items.Add(any2);
            XmlSchemaAttribute attribute = new XmlSchemaAttribute();
            attribute.Name = "namespace";
            attribute.FixedValue = dataset.Namespace;
            type.Attributes.Add(attribute);
            XmlSchemaAttribute attribute2 = new XmlSchemaAttribute();
            attribute2.Name = "tableTypeName";
            attribute2.FixedValue = "PseudoActionVisualizationDataTable";
            type.Attributes.Add(attribute2);
            type.Particle = sequence;
            XmlSchema schemaSerializable = dataset.GetSchemaSerializable();
            if (xs.Contains(schemaSerializable.TargetNamespace))
            {
                MemoryStream stream = new MemoryStream();
                MemoryStream stream2 = new MemoryStream();
                try
                {
                    XmlSchema current = null;
                    schemaSerializable.Write(stream);
                    IEnumerator enumerator = xs.Schemas(schemaSerializable.TargetNamespace).GetEnumerator();
                    while (enumerator.MoveNext())
                    {
                        current = (XmlSchema) enumerator.Current;
                        stream2.SetLength(0L);
                        current.Write(stream2);
                        if (stream.Length == stream2.Length)
                        {
                            stream.Position = 0L;
                            stream2.Position = 0L;
                            while ((stream.Position != stream.Length) && (stream.ReadByte() == stream2.ReadByte()))
                            {
                            }
                            if (stream.Position == stream.Length)
                            {
                                return type;
                            }
                        }
                    }
                }
                finally
                {
                    if (stream != null)
                    {
                        stream.Close();
                    }
                    if (stream2 != null)
                    {
                        stream2.Close();
                    }
                }
            }
            xs.Add(schemaSerializable);
            return type;
        }

        [DebuggerNonUserCode]
        private void InitClass()
        {
            this.columnActionTypeID = new DataColumn("ActionTypeID", typeof(int), null, MappingType.Element);
            base.Columns.Add(this.columnActionTypeID);
            this.columnVisualizationID = new DataColumn("VisualizationID", typeof(int), null, MappingType.Element);
            base.Columns.Add(this.columnVisualizationID);
            base.Constraints.Add(new UniqueConstraint("Constraint1", new DataColumn[] { this.columnActionTypeID, this.columnVisualizationID }, true));
            this.columnActionTypeID.AllowDBNull = false;
            this.columnVisualizationID.AllowDBNull = false;
        }

        [DebuggerNonUserCode]
        internal void InitVars()
        {
            this.columnActionTypeID = base.Columns["ActionTypeID"];
            this.columnVisualizationID = base.Columns["VisualizationID"];
        }

        [DebuggerNonUserCode]
        public ThemeDataset.PseudoActionVisualizationRow NewPseudoActionVisualizationRow()
        {
            return (ThemeDataset.PseudoActionVisualizationRow) base.NewRow();
        }

        [DebuggerNonUserCode]
        protected override DataRow NewRowFromBuilder(DataRowBuilder builder)
        {
            return new ThemeDataset.PseudoActionVisualizationRow(builder);
        }

        [DebuggerNonUserCode]
        protected override void OnRowChanged(DataRowChangeEventArgs e)
        {
            base.OnRowChanged(e);
            if (this.PseudoActionVisualizationRowChanged != null)
            {
                this.PseudoActionVisualizationRowChanged(this, new ThemeDataset.PseudoActionVisualizationRowChangeEvent((ThemeDataset.PseudoActionVisualizationRow) e.Row, e.Action));
            }
        }

        [DebuggerNonUserCode]
        protected override void OnRowChanging(DataRowChangeEventArgs e)
        {
            base.OnRowChanging(e);
            if (this.PseudoActionVisualizationRowChanging != null)
            {
                this.PseudoActionVisualizationRowChanging(this, new ThemeDataset.PseudoActionVisualizationRowChangeEvent((ThemeDataset.PseudoActionVisualizationRow) e.Row, e.Action));
            }
        }

        [DebuggerNonUserCode]
        protected override void OnRowDeleted(DataRowChangeEventArgs e)
        {
            base.OnRowDeleted(e);
            if (this.PseudoActionVisualizationRowDeleted != null)
            {
                this.PseudoActionVisualizationRowDeleted(this, new ThemeDataset.PseudoActionVisualizationRowChangeEvent((ThemeDataset.PseudoActionVisualizationRow) e.Row, e.Action));
            }
        }

        [DebuggerNonUserCode]
        protected override void OnRowDeleting(DataRowChangeEventArgs e)
        {
            base.OnRowDeleting(e);
            if (this.PseudoActionVisualizationRowDeleting != null)
            {
                this.PseudoActionVisualizationRowDeleting(this, new ThemeDataset.PseudoActionVisualizationRowChangeEvent((ThemeDataset.PseudoActionVisualizationRow) e.Row, e.Action));
            }
        }

        [DebuggerNonUserCode]
        public void RemovePseudoActionVisualizationRow(ThemeDataset.PseudoActionVisualizationRow row)
        {
            base.Rows.Remove(row);
        }

        // Properties
        [DebuggerNonUserCode]
        public DataColumn ActionTypeIDColumn
        {
            get
            {
                return this.columnActionTypeID;
            }
        }

        [DebuggerNonUserCode, Browsable(false)]
        public int Count
        {
            get
            {
                return base.Rows.Count;
            }
        }

        [DebuggerNonUserCode]
        public ThemeDataset.PseudoActionVisualizationRow this[int index]
        {
            get
            {
                return (ThemeDataset.PseudoActionVisualizationRow) base.Rows[index];
            }
        }

        [DebuggerNonUserCode]
        public DataColumn VisualizationIDColumn
        {
            get
            {
                return this.columnVisualizationID;
            }
        }
    }

    [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
    public class PseudoActionVisualizationRow : DataRow
    {
        // Fields
        private ThemeDataset.PseudoActionVisualizationDataTable tablePseudoActionVisualization;

        // Methods
        [DebuggerNonUserCode]
        internal PseudoActionVisualizationRow(DataRowBuilder rb) : base(rb)
        {
            this.tablePseudoActionVisualization = (ThemeDataset.PseudoActionVisualizationDataTable) base.Table;
        }

        // Properties
        [DebuggerNonUserCode]
        public int ActionTypeID
        {
            get
            {
                return (int) base[this.tablePseudoActionVisualization.ActionTypeIDColumn];
            }
            set
            {
                base[this.tablePseudoActionVisualization.ActionTypeIDColumn] = value;
            }
        }

        [DebuggerNonUserCode]
        public ThemeDataset.ActionTypesRow ActionTypesRow
        {
            get
            {
                return (ThemeDataset.ActionTypesRow) base.GetParentRow(base.Table.ParentRelations["PseudoActionVisualization_ActionTypes"]);
            }
            set
            {
                base.SetParentRow(value, base.Table.ParentRelations["PseudoActionVisualization_ActionTypes"]);
            }
        }

        [DebuggerNonUserCode]
        public int VisualizationID
        {
            get
            {
                return (int) base[this.tablePseudoActionVisualization.VisualizationIDColumn];
            }
            set
            {
                base[this.tablePseudoActionVisualization.VisualizationIDColumn] = value;
            }
        }

        [DebuggerNonUserCode]
        public ThemeDataset.VisualizationsRow VisualizationsRow
        {
            get
            {
                return (ThemeDataset.VisualizationsRow) base.GetParentRow(base.Table.ParentRelations["PseudoActionVisualization_Visualizations"]);
            }
            set
            {
                base.SetParentRow(value, base.Table.ParentRelations["PseudoActionVisualization_Visualizations"]);
            }
        }
    }

    [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
    public class PseudoActionVisualizationRowChangeEvent : EventArgs
    {
        // Fields
        private DataRowAction eventAction;
        private ThemeDataset.PseudoActionVisualizationRow eventRow;

        // Methods
        [DebuggerNonUserCode]
        public PseudoActionVisualizationRowChangeEvent(ThemeDataset.PseudoActionVisualizationRow row, DataRowAction action)
        {
            this.eventRow = row;
            this.eventAction = action;
        }

        // Properties
        [DebuggerNonUserCode]
        public DataRowAction Action
        {
            get
            {
                return this.eventAction;
            }
        }

        [DebuggerNonUserCode]
        public ThemeDataset.PseudoActionVisualizationRow Row
        {
            get
            {
                return this.eventRow;
            }
        }
    }

    public delegate void PseudoActionVisualizationRowChangeEventHandler(object sender, ThemeDataset.PseudoActionVisualizationRowChangeEvent e);

    [Serializable, XmlSchemaProvider("GetTypedTableSchema"), GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
    public class ThemeDataTable : DataTable, IEnumerable
    {
        // Fields
        private DataColumn columnCompatibleSystem;
        private DataColumn columnMode;
        private DataColumn columnModel;
        private DataColumn columnName;
        private DataColumn columnTempo;
        private DataColumn columnThemeID;
        private DataColumn columnVersion;

        // Events
        public event ThemeDataset.ThemeRowChangeEventHandler ThemeRowChanged;

        public event ThemeDataset.ThemeRowChangeEventHandler ThemeRowChanging;

        public event ThemeDataset.ThemeRowChangeEventHandler ThemeRowDeleted;

        public event ThemeDataset.ThemeRowChangeEventHandler ThemeRowDeleting;

        // Methods
        [DebuggerNonUserCode]
        public ThemeDataTable()
        {
            base.TableName = "Theme";
            this.BeginInit();
            this.InitClass();
            this.EndInit();
        }

        [DebuggerNonUserCode]
        internal ThemeDataTable(DataTable table)
        {
            base.TableName = table.TableName;
            if (table.CaseSensitive != table.DataSet.CaseSensitive)
            {
                base.CaseSensitive = table.CaseSensitive;
            }
            if (table.Locale.ToString() != table.DataSet.Locale.ToString())
            {
                base.Locale = table.Locale;
            }
            if (table.Namespace != table.DataSet.Namespace)
            {
                base.Namespace = table.Namespace;
            }
            base.Prefix = table.Prefix;
            base.MinimumCapacity = table.MinimumCapacity;
        }

        [DebuggerNonUserCode]
        protected ThemeDataTable(SerializationInfo info, StreamingContext context) : base(info, context)
        {
            this.InitVars();
        }

        [DebuggerNonUserCode]
        public void AddThemeRow(ThemeDataset.ThemeRow row)
        {
            base.Rows.Add(row);
        }

        [DebuggerNonUserCode]
        public ThemeDataset.ThemeRow AddThemeRow(string Name, string Version, string Model, int Mode, int Tempo, string CompatibleSystem)
        {
            ThemeDataset.ThemeRow row = (ThemeDataset.ThemeRow) base.NewRow();
            object[] objArray2 = new object[7];
            objArray2[1] = Name;
            objArray2[2] = Version;
            objArray2[3] = Model;
            objArray2[4] = Mode;
            objArray2[5] = Tempo;
            objArray2[6] = CompatibleSystem;
            object[] objArray = objArray2;
            row.ItemArray = objArray;
            base.Rows.Add(row);
            return row;
        }

        [DebuggerNonUserCode]
        public override DataTable Clone()
        {
            ThemeDataset.ThemeDataTable table = (ThemeDataset.ThemeDataTable) base.Clone();
            table.InitVars();
            return table;
        }

        [DebuggerNonUserCode]
        protected override DataTable CreateInstance()
        {
            return new ThemeDataset.ThemeDataTable();
        }

        [DebuggerNonUserCode]
        public ThemeDataset.ThemeRow FindByThemeID(int ThemeID)
        {
            return (ThemeDataset.ThemeRow) base.Rows.Find(new object[] { ThemeID });
        }

        [DebuggerNonUserCode]
        public virtual IEnumerator GetEnumerator()
        {
            return base.Rows.GetEnumerator();
        }

        [DebuggerNonUserCode]
        protected override Type GetRowType()
        {
            return typeof(ThemeDataset.ThemeRow);
        }

        [DebuggerNonUserCode]
        public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs)
        {
            XmlSchemaComplexType type = new XmlSchemaComplexType();
            XmlSchemaSequence sequence = new XmlSchemaSequence();
            ThemeDataset dataset = new ThemeDataset();
            XmlSchemaAny item = new XmlSchemaAny();
            item.Namespace = "http://www.w3.org/2001/XMLSchema";
            item.MinOccurs = 0M;
            item.MaxOccurs = 79228162514264337593543950335M;
            item.ProcessContents = XmlSchemaContentProcessing.Lax;
            sequence.Items.Add(item);
            XmlSchemaAny any2 = new XmlSchemaAny();
            any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
            any2.MinOccurs = 1M;
            any2.ProcessContents = XmlSchemaContentProcessing.Lax;
            sequence.Items.Add(any2);
            XmlSchemaAttribute attribute = new XmlSchemaAttribute();
            attribute.Name = "namespace";
            attribute.FixedValue = dataset.Namespace;
            type.Attributes.Add(attribute);
            XmlSchemaAttribute attribute2 = new XmlSchemaAttribute();
            attribute2.Name = "tableTypeName";
            attribute2.FixedValue = "ThemeDataTable";
            type.Attributes.Add(attribute2);
            type.Particle = sequence;
            XmlSchema schemaSerializable = dataset.GetSchemaSerializable();
            if (xs.Contains(schemaSerializable.TargetNamespace))
            {
                MemoryStream stream = new MemoryStream();
                MemoryStream stream2 = new MemoryStream();
                try
                {
                    XmlSchema current = null;
                    schemaSerializable.Write(stream);
                    IEnumerator enumerator = xs.Schemas(schemaSerializable.TargetNamespace).GetEnumerator();
                    while (enumerator.MoveNext())
                    {
                        current = (XmlSchema) enumerator.Current;
                        stream2.SetLength(0L);
                        current.Write(stream2);
                        if (stream.Length == stream2.Length)
                        {
                            stream.Position = 0L;
                            stream2.Position = 0L;
                            while ((stream.Position != stream.Length) && (stream.ReadByte() == stream2.ReadByte()))
                            {
                            }
                            if (stream.Position == stream.Length)
                            {
                                return type;
                            }
                        }
                    }
                }
                finally
                {
                    if (stream != null)
                    {
                        stream.Close();
                    }
                    if (stream2 != null)
                    {
                        stream2.Close();
                    }
                }
            }
            xs.Add(schemaSerializable);
            return type;
        }

        [DebuggerNonUserCode]
        private void InitClass()
        {
            this.columnThemeID = new DataColumn("ThemeID", typeof(int), null, MappingType.Element);
            base.Columns.Add(this.columnThemeID);
            this.columnName = new DataColumn("Name", typeof(string), null, MappingType.Element);
            base.Columns.Add(this.columnName);
            this.columnVersion = new DataColumn("Version", typeof(string), null, MappingType.Element);
            base.Columns.Add(this.columnVersion);
            this.columnModel = new DataColumn("Model", typeof(string), null, MappingType.Element);
            base.Columns.Add(this.columnModel);
            this.columnMode = new DataColumn("Mode", typeof(int), null, MappingType.Element);
            base.Columns.Add(this.columnMode);
            this.columnTempo = new DataColumn("Tempo", typeof(int), null, MappingType.Element);
            base.Columns.Add(this.columnTempo);
            this.columnCompatibleSystem = new DataColumn("CompatibleSystem", typeof(string), null, MappingType.Element);
            base.Columns.Add(this.columnCompatibleSystem);
            base.Constraints.Add(new UniqueConstraint("Constraint1", new DataColumn[] { this.columnThemeID }, true));
            this.columnThemeID.AutoIncrement = true;
            this.columnThemeID.AllowDBNull = false;
            this.columnThemeID.ReadOnly = true;
            this.columnThemeID.Unique = true;
            this.columnName.AllowDBNull = false;
            this.columnName.MaxLength = 260;
            this.columnVersion.AllowDBNull = false;
            this.columnVersion.MaxLength = 20;
            this.columnModel.AllowDBNull = false;
            this.columnModel.MaxLength = 20;
            this.columnMode.AllowDBNull = false;
            this.columnTempo.AllowDBNull = false;
            this.columnCompatibleSystem.AllowDBNull = false;
            this.columnCompatibleSystem.MaxLength = 400;
        }

        [DebuggerNonUserCode]
        internal void InitVars()
        {
            this.columnThemeID = base.Columns["ThemeID"];
            this.columnName = base.Columns["Name"];
            this.columnVersion = base.Columns["Version"];
            this.columnModel = base.Columns["Model"];
            this.columnMode = base.Columns["Mode"];
            this.columnTempo = base.Columns["Tempo"];
            this.columnCompatibleSystem = base.Columns["CompatibleSystem"];
        }

        [DebuggerNonUserCode]
        protected override DataRow NewRowFromBuilder(DataRowBuilder builder)
        {
            return new ThemeDataset.ThemeRow(builder);
        }

        [DebuggerNonUserCode]
        public ThemeDataset.ThemeRow NewThemeRow()
        {
            return (ThemeDataset.ThemeRow) base.NewRow();
        }

        [DebuggerNonUserCode]
        protected override void OnRowChanged(DataRowChangeEventArgs e)
        {
            base.OnRowChanged(e);
            if (this.ThemeRowChanged != null)
            {
                this.ThemeRowChanged(this, new ThemeDataset.ThemeRowChangeEvent((ThemeDataset.ThemeRow) e.Row, e.Action));
            }
        }

        [DebuggerNonUserCode]
        protected override void OnRowChanging(DataRowChangeEventArgs e)
        {
            base.OnRowChanging(e);
            if (this.ThemeRowChanging != null)
            {
                this.ThemeRowChanging(this, new ThemeDataset.ThemeRowChangeEvent((ThemeDataset.ThemeRow) e.Row, e.Action));
            }
        }

        [DebuggerNonUserCode]
        protected override void OnRowDeleted(DataRowChangeEventArgs e)
        {
            base.OnRowDeleted(e);
            if (this.ThemeRowDeleted != null)
            {
                this.ThemeRowDeleted(this, new ThemeDataset.ThemeRowChangeEvent((ThemeDataset.ThemeRow) e.Row, e.Action));
            }
        }

        [DebuggerNonUserCode]
        protected override void OnRowDeleting(DataRowChangeEventArgs e)
        {
            base.OnRowDeleting(e);
            if (this.ThemeRowDeleting != null)
            {
                this.ThemeRowDeleting(this, new ThemeDataset.ThemeRowChangeEvent((ThemeDataset.ThemeRow) e.Row, e.Action));
            }
        }

        [DebuggerNonUserCode]
        public void RemoveThemeRow(ThemeDataset.ThemeRow row)
        {
            base.Rows.Remove(row);
        }

        // Properties
        [DebuggerNonUserCode]
        public DataColumn CompatibleSystemColumn
        {
            get
            {
                return this.columnCompatibleSystem;
            }
        }

        [Browsable(false), DebuggerNonUserCode]
        public int Count
        {
            get
            {
                return base.Rows.Count;
            }
        }

        [DebuggerNonUserCode]
        public ThemeDataset.ThemeRow this[int index]
        {
            get
            {
                return (ThemeDataset.ThemeRow) base.Rows[index];
            }
        }

        [DebuggerNonUserCode]
        public DataColumn ModeColumn
        {
            get
            {
                return this.columnMode;
            }
        }

        [DebuggerNonUserCode]
        public DataColumn ModelColumn
        {
            get
            {
                return this.columnModel;
            }
        }

        [DebuggerNonUserCode]
        public DataColumn NameColumn
        {
            get
            {
                return this.columnName;
            }
        }

        [DebuggerNonUserCode]
        public DataColumn TempoColumn
        {
            get
            {
                return this.columnTempo;
            }
        }

        [DebuggerNonUserCode]
        public DataColumn ThemeIDColumn
        {
            get
            {
                return this.columnThemeID;
            }
        }

        [DebuggerNonUserCode]
        public DataColumn VersionColumn
        {
            get
            {
                return this.columnVersion;
            }
        }
    }

    [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
    public class ThemeRow : DataRow
    {
        // Fields
        private ThemeDataset.ThemeDataTable tableTheme;

        // Methods
        [DebuggerNonUserCode]
        internal ThemeRow(DataRowBuilder rb) : base(rb)
        {
            this.tableTheme = (ThemeDataset.ThemeDataTable) base.Table;
        }

        [DebuggerNonUserCode]
        public ThemeDataset.VisualizationsRow[] GetVisualizationsRows()
        {
            if (base.Table.ChildRelations["Visualizations_Theme"] == null)
            {
                return new ThemeDataset.VisualizationsRow[0];
            }
            return (ThemeDataset.VisualizationsRow[]) base.GetChildRows(base.Table.ChildRelations["Visualizations_Theme"]);
        }

        // Properties
        [DebuggerNonUserCode]
        public string CompatibleSystem
        {
            get
            {
                return (string) base[this.tableTheme.CompatibleSystemColumn];
            }
            set
            {
                base[this.tableTheme.CompatibleSystemColumn] = value;
            }
        }

        [DebuggerNonUserCode]
        public int Mode
        {
            get
            {
                return (int) base[this.tableTheme.ModeColumn];
            }
            set
            {
                base[this.tableTheme.ModeColumn] = value;
            }
        }

        [DebuggerNonUserCode]
        public string Model
        {
            get
            {
                return (string) base[this.tableTheme.ModelColumn];
            }
            set
            {
                base[this.tableTheme.ModelColumn] = value;
            }
        }

        [DebuggerNonUserCode]
        public string Name
        {
            get
            {
                return (string) base[this.tableTheme.NameColumn];
            }
            set
            {
                base[this.tableTheme.NameColumn] = value;
            }
        }

        [DebuggerNonUserCode]
        public int Tempo
        {
            get
            {
                return (int) base[this.tableTheme.TempoColumn];
            }
            set
            {
                base[this.tableTheme.TempoColumn] = value;
            }
        }

        [DebuggerNonUserCode]
        public int ThemeID
        {
            get
            {
                return (int) base[this.tableTheme.ThemeIDColumn];
            }
            set
            {
                base[this.tableTheme.ThemeIDColumn] = value;
            }
        }

        [DebuggerNonUserCode]
        public string Version
        {
            get
            {
                return (string) base[this.tableTheme.VersionColumn];
            }
            set
            {
                base[this.tableTheme.VersionColumn] = value;
            }
        }
    }

    [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
    public class ThemeRowChangeEvent : EventArgs
    {
        // Fields
        private DataRowAction eventAction;
        private ThemeDataset.ThemeRow eventRow;

        // Methods
        [DebuggerNonUserCode]
        public ThemeRowChangeEvent(ThemeDataset.ThemeRow row, DataRowAction action)
        {
            this.eventRow = row;
            this.eventAction = action;
        }

        // Properties
        [DebuggerNonUserCode]
        public DataRowAction Action
        {
            get
            {
                return this.eventAction;
            }
        }

        [DebuggerNonUserCode]
        public ThemeDataset.ThemeRow Row
        {
            get
            {
                return this.eventRow;
            }
        }
    }

    public delegate void ThemeRowChangeEventHandler(object sender, ThemeDataset.ThemeRowChangeEvent e);

    [Serializable, XmlSchemaProvider("GetTypedTableSchema"), GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
    public class VisualizationsDataTable : DataTable, IEnumerable
    {
        // Fields
        private DataColumn columnApplicationName;
        private DataColumn columnName;
        private DataColumn columnThemeID;
        private DataColumn columnVisualizationID;
        private DataColumn columnVisualizationTypeID;

        // Events
        public event ThemeDataset.VisualizationsRowChangeEventHandler VisualizationsRowChanged;

        public event ThemeDataset.VisualizationsRowChangeEventHandler VisualizationsRowChanging;

        public event ThemeDataset.VisualizationsRowChangeEventHandler VisualizationsRowDeleted;

        public event ThemeDataset.VisualizationsRowChangeEventHandler VisualizationsRowDeleting;

        // Methods
        [DebuggerNonUserCode]
        public VisualizationsDataTable()
        {
            base.TableName = "Visualizations";
            this.BeginInit();
            this.InitClass();
            this.EndInit();
        }

        [DebuggerNonUserCode]
        internal VisualizationsDataTable(DataTable table)
        {
            base.TableName = table.TableName;
            if (table.CaseSensitive != table.DataSet.CaseSensitive)
            {
                base.CaseSensitive = table.CaseSensitive;
            }
            if (table.Locale.ToString() != table.DataSet.Locale.ToString())
            {
                base.Locale = table.Locale;
            }
            if (table.Namespace != table.DataSet.Namespace)
            {
                base.Namespace = table.Namespace;
            }
            base.Prefix = table.Prefix;
            base.MinimumCapacity = table.MinimumCapacity;
        }

        [DebuggerNonUserCode]
        protected VisualizationsDataTable(SerializationInfo info, StreamingContext context) : base(info, context)
        {
            this.InitVars();
        }

        [DebuggerNonUserCode]
        public void AddVisualizationsRow(ThemeDataset.VisualizationsRow row)
        {
            base.Rows.Add(row);
        }

        [DebuggerNonUserCode]
        public ThemeDataset.VisualizationsRow AddVisualizationsRow(int VisualizationID, string Name, ThemeDataset.VisualizationTypesRow parentVisualizationTypesRowByVisualizations_VisualizationTypes, ThemeDataset.ThemeRow parentThemeRowByVisualizations_Theme, string ApplicationName)
        {
            ThemeDataset.VisualizationsRow row = (ThemeDataset.VisualizationsRow) base.NewRow();
            object[] objArray2 = new object[5];
            objArray2[0] = VisualizationID;
            objArray2[1] = Name;
            objArray2[4] = ApplicationName;
            object[] objArray = objArray2;
            if (parentVisualizationTypesRowByVisualizations_VisualizationTypes != null)
            {
                objArray[2] = parentVisualizationTypesRowByVisualizations_VisualizationTypes[0];
            }
            if (parentThemeRowByVisualizations_Theme != null)
            {
                objArray[3] = parentThemeRowByVisualizations_Theme[0];
            }
            row.ItemArray = objArray;
            base.Rows.Add(row);
            return row;
        }

        [DebuggerNonUserCode]
        public override DataTable Clone()
        {
            ThemeDataset.VisualizationsDataTable table = (ThemeDataset.VisualizationsDataTable) base.Clone();
            table.InitVars();
            return table;
        }

        [DebuggerNonUserCode]
        protected override DataTable CreateInstance()
        {
            return new ThemeDataset.VisualizationsDataTable();
        }

        [DebuggerNonUserCode]
        public ThemeDataset.VisualizationsRow FindByVisualizationID(int VisualizationID)
        {
            return (ThemeDataset.VisualizationsRow) base.Rows.Find(new object[] { VisualizationID });
        }

        [DebuggerNonUserCode]
        public virtual IEnumerator GetEnumerator()
        {
            return base.Rows.GetEnumerator();
        }

        [DebuggerNonUserCode]
        protected override Type GetRowType()
        {
            return typeof(ThemeDataset.VisualizationsRow);
        }

        [DebuggerNonUserCode]
        public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs)
        {
            XmlSchemaComplexType type = new XmlSchemaComplexType();
            XmlSchemaSequence sequence = new XmlSchemaSequence();
            ThemeDataset dataset = new ThemeDataset();
            XmlSchemaAny item = new XmlSchemaAny();
            item.Namespace = "http://www.w3.org/2001/XMLSchema";
            item.MinOccurs = 0M;
            item.MaxOccurs = 79228162514264337593543950335M;
            item.ProcessContents = XmlSchemaContentProcessing.Lax;
            sequence.Items.Add(item);
            XmlSchemaAny any2 = new XmlSchemaAny();
            any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
            any2.MinOccurs = 1M;
            any2.ProcessContents = XmlSchemaContentProcessing.Lax;
            sequence.Items.Add(any2);
            XmlSchemaAttribute attribute = new XmlSchemaAttribute();
            attribute.Name = "namespace";
            attribute.FixedValue = dataset.Namespace;
            type.Attributes.Add(attribute);
            XmlSchemaAttribute attribute2 = new XmlSchemaAttribute();
            attribute2.Name = "tableTypeName";
            attribute2.FixedValue = "VisualizationsDataTable";
            type.Attributes.Add(attribute2);
            type.Particle = sequence;
            XmlSchema schemaSerializable = dataset.GetSchemaSerializable();
            if (xs.Contains(schemaSerializable.TargetNamespace))
            {
                MemoryStream stream = new MemoryStream();
                MemoryStream stream2 = new MemoryStream();
                try
                {
                    XmlSchema current = null;
                    schemaSerializable.Write(stream);
                    IEnumerator enumerator = xs.Schemas(schemaSerializable.TargetNamespace).GetEnumerator();
                    while (enumerator.MoveNext())
                    {
                        current = (XmlSchema) enumerator.Current;
                        stream2.SetLength(0L);
                        current.Write(stream2);
                        if (stream.Length == stream2.Length)
                        {
                            stream.Position = 0L;
                            stream2.Position = 0L;
                            while ((stream.Position != stream.Length) && (stream.ReadByte() == stream2.ReadByte()))
                            {
                            }
                            if (stream.Position == stream.Length)
                            {
                                return type;
                            }
                        }
                    }
                }
                finally
                {
                    if (stream != null)
                    {
                        stream.Close();
                    }
                    if (stream2 != null)
                    {
                        stream2.Close();
                    }
                }
            }
            xs.Add(schemaSerializable);
            return type;
        }

        [DebuggerNonUserCode]
        private void InitClass()
        {
            this.columnVisualizationID = new DataColumn("VisualizationID", typeof(int), null, MappingType.Element);
            base.Columns.Add(this.columnVisualizationID);
            this.columnName = new DataColumn("Name", typeof(string), null, MappingType.Element);
            base.Columns.Add(this.columnName);
            this.columnVisualizationTypeID = new DataColumn("VisualizationTypeID", typeof(int), null, MappingType.Element);
            base.Columns.Add(this.columnVisualizationTypeID);
            this.columnThemeID = new DataColumn("ThemeID", typeof(int), null, MappingType.Element);
            base.Columns.Add(this.columnThemeID);
            this.columnApplicationName = new DataColumn("ApplicationName", typeof(string), null, MappingType.Element);
            base.Columns.Add(this.columnApplicationName);
            base.Constraints.Add(new UniqueConstraint("Constraint1", new DataColumn[] { this.columnVisualizationID }, true));
            this.columnVisualizationID.AllowDBNull = false;
            this.columnVisualizationID.Unique = true;
            this.columnName.AllowDBNull = false;
            this.columnName.MaxLength = 50;
            this.columnVisualizationTypeID.AllowDBNull = false;
            this.columnThemeID.AllowDBNull = false;
            this.columnApplicationName.AllowDBNull = false;
            this.columnApplicationName.MaxLength = 50;
        }

        [DebuggerNonUserCode]
        internal void InitVars()
        {
            this.columnVisualizationID = base.Columns["VisualizationID"];
            this.columnName = base.Columns["Name"];
            this.columnVisualizationTypeID = base.Columns["VisualizationTypeID"];
            this.columnThemeID = base.Columns["ThemeID"];
            this.columnApplicationName = base.Columns["ApplicationName"];
        }

        [DebuggerNonUserCode]
        protected override DataRow NewRowFromBuilder(DataRowBuilder builder)
        {
            return new ThemeDataset.VisualizationsRow(builder);
        }

        [DebuggerNonUserCode]
        public ThemeDataset.VisualizationsRow NewVisualizationsRow()
        {
            return (ThemeDataset.VisualizationsRow) base.NewRow();
        }

        [DebuggerNonUserCode]
        protected override void OnRowChanged(DataRowChangeEventArgs e)
        {
            base.OnRowChanged(e);
            if (this.VisualizationsRowChanged != null)
            {
                this.VisualizationsRowChanged(this, new ThemeDataset.VisualizationsRowChangeEvent((ThemeDataset.VisualizationsRow) e.Row, e.Action));
            }
        }

        [DebuggerNonUserCode]
        protected override void OnRowChanging(DataRowChangeEventArgs e)
        {
            base.OnRowChanging(e);
            if (this.VisualizationsRowChanging != null)
            {
                this.VisualizationsRowChanging(this, new ThemeDataset.VisualizationsRowChangeEvent((ThemeDataset.VisualizationsRow) e.Row, e.Action));
            }
        }

        [DebuggerNonUserCode]
        protected override void OnRowDeleted(DataRowChangeEventArgs e)
        {
            base.OnRowDeleted(e);
            if (this.VisualizationsRowDeleted != null)
            {
                this.VisualizationsRowDeleted(this, new ThemeDataset.VisualizationsRowChangeEvent((ThemeDataset.VisualizationsRow) e.Row, e.Action));
            }
        }

        [DebuggerNonUserCode]
        protected override void OnRowDeleting(DataRowChangeEventArgs e)
        {
            base.OnRowDeleting(e);
            if (this.VisualizationsRowDeleting != null)
            {
                this.VisualizationsRowDeleting(this, new ThemeDataset.VisualizationsRowChangeEvent((ThemeDataset.VisualizationsRow) e.Row, e.Action));
            }
        }

        [DebuggerNonUserCode]
        public void RemoveVisualizationsRow(ThemeDataset.VisualizationsRow row)
        {
            base.Rows.Remove(row);
        }

        // Properties
        [DebuggerNonUserCode]
        public DataColumn ApplicationNameColumn
        {
            get
            {
                return this.columnApplicationName;
            }
        }

        [Browsable(false), DebuggerNonUserCode]
        public int Count
        {
            get
            {
                return base.Rows.Count;
            }
        }

        [DebuggerNonUserCode]
        public ThemeDataset.VisualizationsRow this[int index]
        {
            get
            {
                return (ThemeDataset.VisualizationsRow) base.Rows[index];
            }
        }

        [DebuggerNonUserCode]
        public DataColumn NameColumn
        {
            get
            {
                return this.columnName;
            }
        }

        [DebuggerNonUserCode]
        public DataColumn ThemeIDColumn
        {
            get
            {
                return this.columnThemeID;
            }
        }

        [DebuggerNonUserCode]
        public DataColumn VisualizationIDColumn
        {
            get
            {
                return this.columnVisualizationID;
            }
        }

        [DebuggerNonUserCode]
        public DataColumn VisualizationTypeIDColumn
        {
            get
            {
                return this.columnVisualizationTypeID;
            }
        }
    }

    [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
    public class VisualizationsRow : DataRow
    {
        // Fields
        private ThemeDataset.VisualizationsDataTable tableVisualizations;

        // Methods
        [DebuggerNonUserCode]
        internal VisualizationsRow(DataRowBuilder rb) : base(rb)
        {
            this.tableVisualizations = (ThemeDataset.VisualizationsDataTable) base.Table;
        }

        [DebuggerNonUserCode]
        public ThemeDataset.PseudoActionVisualizationRow[] GetPseudoActionVisualizationRows()
        {
            if (base.Table.ChildRelations["PseudoActionVisualization_Visualizations"] == null)
            {
                return new ThemeDataset.PseudoActionVisualizationRow[0];
            }
            return (ThemeDataset.PseudoActionVisualizationRow[]) base.GetChildRows(base.Table.ChildRelations["PseudoActionVisualization_Visualizations"]);
        }

        [DebuggerNonUserCode]
        public ThemeDataset.ZonesRow[] GetZonesRows()
        {
            if (base.Table.ChildRelations["Zones_Visualizations"] == null)
            {
                return new ThemeDataset.ZonesRow[0];
            }
            return (ThemeDataset.ZonesRow[]) base.GetChildRows(base.Table.ChildRelations["Zones_Visualizations"]);
        }

        // Properties
        [DebuggerNonUserCode]
        public string ApplicationName
        {
            get
            {
                return (string) base[this.tableVisualizations.ApplicationNameColumn];
            }
            set
            {
                base[this.tableVisualizations.ApplicationNameColumn] = value;
            }
        }

        [DebuggerNonUserCode]
        public string Name
        {
            get
            {
                return (string) base[this.tableVisualizations.NameColumn];
            }
            set
            {
                base[this.tableVisualizations.NameColumn] = value;
            }
        }

        [DebuggerNonUserCode]
        public int ThemeID
        {
            get
            {
                return (int) base[this.tableVisualizations.ThemeIDColumn];
            }
            set
            {
                base[this.tableVisualizations.ThemeIDColumn] = value;
            }
        }

        [DebuggerNonUserCode]
        public ThemeDataset.ThemeRow ThemeRow
        {
            get
            {
                return (ThemeDataset.ThemeRow) base.GetParentRow(base.Table.ParentRelations["Visualizations_Theme"]);
            }
            set
            {
                base.SetParentRow(value, base.Table.ParentRelations["Visualizations_Theme"]);
            }
        }

        [DebuggerNonUserCode]
        public int VisualizationID
        {
            get
            {
                return (int) base[this.tableVisualizations.VisualizationIDColumn];
            }
            set
            {
                base[this.tableVisualizations.VisualizationIDColumn] = value;
            }
        }

        [DebuggerNonUserCode]
        public int VisualizationTypeID
        {
            get
            {
                return (int) base[this.tableVisualizations.VisualizationTypeIDColumn];
            }
            set
            {
                base[this.tableVisualizations.VisualizationTypeIDColumn] = value;
            }
        }

        [DebuggerNonUserCode]
        public ThemeDataset.VisualizationTypesRow VisualizationTypesRow
        {
            get
            {
                return (ThemeDataset.VisualizationTypesRow) base.GetParentRow(base.Table.ParentRelations["Visualizations_VisualizationTypes"]);
            }
            set
            {
                base.SetParentRow(value, base.Table.ParentRelations["Visualizations_VisualizationTypes"]);
            }
        }
    }

    [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
    public class VisualizationsRowChangeEvent : EventArgs
    {
        // Fields
        private DataRowAction eventAction;
        private ThemeDataset.VisualizationsRow eventRow;

        // Methods
        [DebuggerNonUserCode]
        public VisualizationsRowChangeEvent(ThemeDataset.VisualizationsRow row, DataRowAction action)
        {
            this.eventRow = row;
            this.eventAction = action;
        }

        // Properties
        [DebuggerNonUserCode]
        public DataRowAction Action
        {
            get
            {
                return this.eventAction;
            }
        }

        [DebuggerNonUserCode]
        public ThemeDataset.VisualizationsRow Row
        {
            get
            {
                return this.eventRow;
            }
        }
    }

    public delegate void VisualizationsRowChangeEventHandler(object sender, ThemeDataset.VisualizationsRowChangeEvent e);

    [Serializable, GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0"), XmlSchemaProvider("GetTypedTableSchema")]
    public class VisualizationTypesDataTable : DataTable, IEnumerable
    {
        // Fields
        private DataColumn columnHidden;
        private DataColumn columnName;
        private DataColumn columnToken;
        private DataColumn columnVisualizationTypeID;

        // Events
        public event ThemeDataset.VisualizationTypesRowChangeEventHandler VisualizationTypesRowChanged;

        public event ThemeDataset.VisualizationTypesRowChangeEventHandler VisualizationTypesRowChanging;

        public event ThemeDataset.VisualizationTypesRowChangeEventHandler VisualizationTypesRowDeleted;

        public event ThemeDataset.VisualizationTypesRowChangeEventHandler VisualizationTypesRowDeleting;

        // Methods
        [DebuggerNonUserCode]
        public VisualizationTypesDataTable()
        {
            base.TableName = "VisualizationTypes";
            this.BeginInit();
            this.InitClass();
            this.EndInit();
        }

        [DebuggerNonUserCode]
        internal VisualizationTypesDataTable(DataTable table)
        {
            base.TableName = table.TableName;
            if (table.CaseSensitive != table.DataSet.CaseSensitive)
            {
                base.CaseSensitive = table.CaseSensitive;
            }
            if (table.Locale.ToString() != table.DataSet.Locale.ToString())
            {
                base.Locale = table.Locale;
            }
            if (table.Namespace != table.DataSet.Namespace)
            {
                base.Namespace = table.Namespace;
            }
            base.Prefix = table.Prefix;
            base.MinimumCapacity = table.MinimumCapacity;
        }

        [DebuggerNonUserCode]
        protected VisualizationTypesDataTable(SerializationInfo info, StreamingContext context) : base(info, context)
        {
            this.InitVars();
        }

        [DebuggerNonUserCode]
        public void AddVisualizationTypesRow(ThemeDataset.VisualizationTypesRow row)
        {
            base.Rows.Add(row);
        }

        [DebuggerNonUserCode]
        public ThemeDataset.VisualizationTypesRow AddVisualizationTypesRow(int VisualizationTypeID, string Name, int Token, bool Hidden)
        {
            ThemeDataset.VisualizationTypesRow row = (ThemeDataset.VisualizationTypesRow) base.NewRow();
            row.ItemArray = new object[] { VisualizationTypeID, Name, Token, Hidden };
            base.Rows.Add(row);
            return row;
        }

        [DebuggerNonUserCode]
        public override DataTable Clone()
        {
            ThemeDataset.VisualizationTypesDataTable table = (ThemeDataset.VisualizationTypesDataTable) base.Clone();
            table.InitVars();
            return table;
        }

        [DebuggerNonUserCode]
        protected override DataTable CreateInstance()
        {
            return new ThemeDataset.VisualizationTypesDataTable();
        }

        [DebuggerNonUserCode]
        public ThemeDataset.VisualizationTypesRow FindByVisualizationTypeID(int VisualizationTypeID)
        {
            return (ThemeDataset.VisualizationTypesRow) base.Rows.Find(new object[] { VisualizationTypeID });
        }

        [DebuggerNonUserCode]
        public virtual IEnumerator GetEnumerator()
        {
            return base.Rows.GetEnumerator();
        }

        [DebuggerNonUserCode]
        protected override Type GetRowType()
        {
            return typeof(ThemeDataset.VisualizationTypesRow);
        }

        [DebuggerNonUserCode]
        public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs)
        {
            XmlSchemaComplexType type = new XmlSchemaComplexType();
            XmlSchemaSequence sequence = new XmlSchemaSequence();
            ThemeDataset dataset = new ThemeDataset();
            XmlSchemaAny item = new XmlSchemaAny();
            item.Namespace = "http://www.w3.org/2001/XMLSchema";
            item.MinOccurs = 0M;
            item.MaxOccurs = 79228162514264337593543950335M;
            item.ProcessContents = XmlSchemaContentProcessing.Lax;
            sequence.Items.Add(item);
            XmlSchemaAny any2 = new XmlSchemaAny();
            any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
            any2.MinOccurs = 1M;
            any2.ProcessContents = XmlSchemaContentProcessing.Lax;
            sequence.Items.Add(any2);
            XmlSchemaAttribute attribute = new XmlSchemaAttribute();
            attribute.Name = "namespace";
            attribute.FixedValue = dataset.Namespace;
            type.Attributes.Add(attribute);
            XmlSchemaAttribute attribute2 = new XmlSchemaAttribute();
            attribute2.Name = "tableTypeName";
            attribute2.FixedValue = "VisualizationTypesDataTable";
            type.Attributes.Add(attribute2);
            type.Particle = sequence;
            XmlSchema schemaSerializable = dataset.GetSchemaSerializable();
            if (xs.Contains(schemaSerializable.TargetNamespace))
            {
                MemoryStream stream = new MemoryStream();
                MemoryStream stream2 = new MemoryStream();
                try
                {
                    XmlSchema current = null;
                    schemaSerializable.Write(stream);
                    IEnumerator enumerator = xs.Schemas(schemaSerializable.TargetNamespace).GetEnumerator();
                    while (enumerator.MoveNext())
                    {
                        current = (XmlSchema) enumerator.Current;
                        stream2.SetLength(0L);
                        current.Write(stream2);
                        if (stream.Length == stream2.Length)
                        {
                            stream.Position = 0L;
                            stream2.Position = 0L;
                            while ((stream.Position != stream.Length) && (stream.ReadByte() == stream2.ReadByte()))
                            {
                            }
                            if (stream.Position == stream.Length)
                            {
                                return type;
                            }
                        }
                    }
                }
                finally
                {
                    if (stream != null)
                    {
                        stream.Close();
                    }
                    if (stream2 != null)
                    {
                        stream2.Close();
                    }
                }
            }
            xs.Add(schemaSerializable);
            return type;
        }

        [DebuggerNonUserCode]
        private void InitClass()
        {
            this.columnVisualizationTypeID = new DataColumn("VisualizationTypeID", typeof(int), null, MappingType.Element);
            base.Columns.Add(this.columnVisualizationTypeID);
            this.columnName = new DataColumn("Name", typeof(string), null, MappingType.Element);
            base.Columns.Add(this.columnName);
            this.columnToken = new DataColumn("Token", typeof(int), null, MappingType.Element);
            base.Columns.Add(this.columnToken);
            this.columnHidden = new DataColumn("Hidden", typeof(bool), null, MappingType.Element);
            base.Columns.Add(this.columnHidden);
            base.Constraints.Add(new UniqueConstraint("Constraint1", new DataColumn[] { this.columnVisualizationTypeID }, true));
            this.columnVisualizationTypeID.AllowDBNull = false;
            this.columnVisualizationTypeID.Unique = true;
            this.columnName.AllowDBNull = false;
            this.columnName.MaxLength = 50;
            this.columnToken.AllowDBNull = false;
            this.columnHidden.AllowDBNull = false;
        }

        [DebuggerNonUserCode]
        internal void InitVars()
        {
            this.columnVisualizationTypeID = base.Columns["VisualizationTypeID"];
            this.columnName = base.Columns["Name"];
            this.columnToken = base.Columns["Token"];
            this.columnHidden = base.Columns["Hidden"];
        }

        [DebuggerNonUserCode]
        protected override DataRow NewRowFromBuilder(DataRowBuilder builder)
        {
            return new ThemeDataset.VisualizationTypesRow(builder);
        }

        [DebuggerNonUserCode]
        public ThemeDataset.VisualizationTypesRow NewVisualizationTypesRow()
        {
            return (ThemeDataset.VisualizationTypesRow) base.NewRow();
        }

        [DebuggerNonUserCode]
        protected override void OnRowChanged(DataRowChangeEventArgs e)
        {
            base.OnRowChanged(e);
            if (this.VisualizationTypesRowChanged != null)
            {
                this.VisualizationTypesRowChanged(this, new ThemeDataset.VisualizationTypesRowChangeEvent((ThemeDataset.VisualizationTypesRow) e.Row, e.Action));
            }
        }

        [DebuggerNonUserCode]
        protected override void OnRowChanging(DataRowChangeEventArgs e)
        {
            base.OnRowChanging(e);
            if (this.VisualizationTypesRowChanging != null)
            {
                this.VisualizationTypesRowChanging(this, new ThemeDataset.VisualizationTypesRowChangeEvent((ThemeDataset.VisualizationTypesRow) e.Row, e.Action));
            }
        }

        [DebuggerNonUserCode]
        protected override void OnRowDeleted(DataRowChangeEventArgs e)
        {
            base.OnRowDeleted(e);
            if (this.VisualizationTypesRowDeleted != null)
            {
                this.VisualizationTypesRowDeleted(this, new ThemeDataset.VisualizationTypesRowChangeEvent((ThemeDataset.VisualizationTypesRow) e.Row, e.Action));
            }
        }

        [DebuggerNonUserCode]
        protected override void OnRowDeleting(DataRowChangeEventArgs e)
        {
            base.OnRowDeleting(e);
            if (this.VisualizationTypesRowDeleting != null)
            {
                this.VisualizationTypesRowDeleting(this, new ThemeDataset.VisualizationTypesRowChangeEvent((ThemeDataset.VisualizationTypesRow) e.Row, e.Action));
            }
        }

        [DebuggerNonUserCode]
        public void RemoveVisualizationTypesRow(ThemeDataset.VisualizationTypesRow row)
        {
            base.Rows.Remove(row);
        }

        // Properties
        [DebuggerNonUserCode, Browsable(false)]
        public int Count
        {
            get
            {
                return base.Rows.Count;
            }
        }

        [DebuggerNonUserCode]
        public DataColumn HiddenColumn
        {
            get
            {
                return this.columnHidden;
            }
        }

        [DebuggerNonUserCode]
        public ThemeDataset.VisualizationTypesRow this[int index]
        {
            get
            {
                return (ThemeDataset.VisualizationTypesRow) base.Rows[index];
            }
        }

        [DebuggerNonUserCode]
        public DataColumn NameColumn
        {
            get
            {
                return this.columnName;
            }
        }

        [DebuggerNonUserCode]
        public DataColumn TokenColumn
        {
            get
            {
                return this.columnToken;
            }
        }

        [DebuggerNonUserCode]
        public DataColumn VisualizationTypeIDColumn
        {
            get
            {
                return this.columnVisualizationTypeID;
            }
        }
    }

    [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
    public class VisualizationTypesRow : DataRow
    {
        // Fields
        private ThemeDataset.VisualizationTypesDataTable tableVisualizationTypes;

        // Methods
        [DebuggerNonUserCode]
        internal VisualizationTypesRow(DataRowBuilder rb) : base(rb)
        {
            this.tableVisualizationTypes = (ThemeDataset.VisualizationTypesDataTable) base.Table;
        }

        [DebuggerNonUserCode]
        public ThemeDataset.VisualizationsRow[] GetVisualizationsRows()
        {
            if (base.Table.ChildRelations["Visualizations_VisualizationTypes"] == null)
            {
                return new ThemeDataset.VisualizationsRow[0];
            }
            return (ThemeDataset.VisualizationsRow[]) base.GetChildRows(base.Table.ChildRelations["Visualizations_VisualizationTypes"]);
        }

        // Properties
        [DebuggerNonUserCode]
        public bool Hidden
        {
            get
            {
                return (bool) base[this.tableVisualizationTypes.HiddenColumn];
            }
            set
            {
                base[this.tableVisualizationTypes.HiddenColumn] = value;
            }
        }

        [DebuggerNonUserCode]
        public string Name
        {
            get
            {
                return (string) base[this.tableVisualizationTypes.NameColumn];
            }
            set
            {
                base[this.tableVisualizationTypes.NameColumn] = value;
            }
        }

        [DebuggerNonUserCode]
        public int Token
        {
            get
            {
                return (int) base[this.tableVisualizationTypes.TokenColumn];
            }
            set
            {
                base[this.tableVisualizationTypes.TokenColumn] = value;
            }
        }

        [DebuggerNonUserCode]
        public int VisualizationTypeID
        {
            get
            {
                return (int) base[this.tableVisualizationTypes.VisualizationTypeIDColumn];
            }
            set
            {
                base[this.tableVisualizationTypes.VisualizationTypeIDColumn] = value;
            }
        }
    }

    [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
    public class VisualizationTypesRowChangeEvent : EventArgs
    {
        // Fields
        private DataRowAction eventAction;
        private ThemeDataset.VisualizationTypesRow eventRow;

        // Methods
        [DebuggerNonUserCode]
        public VisualizationTypesRowChangeEvent(ThemeDataset.VisualizationTypesRow row, DataRowAction action)
        {
            this.eventRow = row;
            this.eventAction = action;
        }

        // Properties
        [DebuggerNonUserCode]
        public DataRowAction Action
        {
            get
            {
                return this.eventAction;
            }
        }

        [DebuggerNonUserCode]
        public ThemeDataset.VisualizationTypesRow Row
        {
            get
            {
                return this.eventRow;
            }
        }
    }

    public delegate void VisualizationTypesRowChangeEventHandler(object sender, ThemeDataset.VisualizationTypesRowChangeEvent e);

    [Serializable, XmlSchemaProvider("GetTypedTableSchema"), GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
    public class ZonesDataTable : DataTable, IEnumerable
    {
        // Fields
        private DataColumn columnFixed;
        private DataColumn columnFlags;
        private DataColumn columnFlagsUsedForReplication;
        private DataColumn columnID;
        private DataColumn columnLoop;
        private DataColumn columnName;
        private DataColumn columnVisualizationID;
        private DataColumn columnZoneID;

        // Events
        public event ThemeDataset.ZonesRowChangeEventHandler ZonesRowChanged;

        public event ThemeDataset.ZonesRowChangeEventHandler ZonesRowChanging;

        public event ThemeDataset.ZonesRowChangeEventHandler ZonesRowDeleted;

        public event ThemeDataset.ZonesRowChangeEventHandler ZonesRowDeleting;

        // Methods
        [DebuggerNonUserCode]
        public ZonesDataTable()
        {
            base.TableName = "Zones";
            this.BeginInit();
            this.InitClass();
            this.EndInit();
        }

        [DebuggerNonUserCode]
        internal ZonesDataTable(DataTable table)
        {
            base.TableName = table.TableName;
            if (table.CaseSensitive != table.DataSet.CaseSensitive)
            {
                base.CaseSensitive = table.CaseSensitive;
            }
            if (table.Locale.ToString() != table.DataSet.Locale.ToString())
            {
                base.Locale = table.Locale;
            }
            if (table.Namespace != table.DataSet.Namespace)
            {
                base.Namespace = table.Namespace;
            }
            base.Prefix = table.Prefix;
            base.MinimumCapacity = table.MinimumCapacity;
        }

        [DebuggerNonUserCode]
        protected ZonesDataTable(SerializationInfo info, StreamingContext context) : base(info, context)
        {
            this.InitVars();
        }

        [DebuggerNonUserCode]
        public void AddZonesRow(ThemeDataset.ZonesRow row)
        {
            base.Rows.Add(row);
        }

        [DebuggerNonUserCode]
        public ThemeDataset.ZonesRow AddZonesRow(ThemeDataset.VisualizationsRow parentVisualizationsRowByZones_Visualizations, string Name, bool Loop, string Flags, bool Fixed, int ID, string FlagsUsedForReplication)
        {
            ThemeDataset.ZonesRow row = (ThemeDataset.ZonesRow) base.NewRow();
            object[] objArray2 = new object[8];
            objArray2[2] = Name;
            objArray2[3] = Loop;
            objArray2[4] = Flags;
            objArray2[5] = Fixed;
            objArray2[6] = ID;
            objArray2[7] = FlagsUsedForReplication;
            object[] objArray = objArray2;
            if (parentVisualizationsRowByZones_Visualizations != null)
            {
                objArray[0] = parentVisualizationsRowByZones_Visualizations[0];
            }
            row.ItemArray = objArray;
            base.Rows.Add(row);
            return row;
        }

        [DebuggerNonUserCode]
        public override DataTable Clone()
        {
            ThemeDataset.ZonesDataTable table = (ThemeDataset.ZonesDataTable) base.Clone();
            table.InitVars();
            return table;
        }

        [DebuggerNonUserCode]
        protected override DataTable CreateInstance()
        {
            return new ThemeDataset.ZonesDataTable();
        }

        [DebuggerNonUserCode]
        public ThemeDataset.ZonesRow FindByZoneID(int ZoneID)
        {
            return (ThemeDataset.ZonesRow) base.Rows.Find(new object[] { ZoneID });
        }

        [DebuggerNonUserCode]
        public virtual IEnumerator GetEnumerator()
        {
            return base.Rows.GetEnumerator();
        }

        [DebuggerNonUserCode]
        protected override Type GetRowType()
        {
            return typeof(ThemeDataset.ZonesRow);
        }

        [DebuggerNonUserCode]
        public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs)
        {
            XmlSchemaComplexType type = new XmlSchemaComplexType();
            XmlSchemaSequence sequence = new XmlSchemaSequence();
            ThemeDataset dataset = new ThemeDataset();
            XmlSchemaAny item = new XmlSchemaAny();
            item.Namespace = "http://www.w3.org/2001/XMLSchema";
            item.MinOccurs = 0M;
            item.MaxOccurs = 79228162514264337593543950335M;
            item.ProcessContents = XmlSchemaContentProcessing.Lax;
            sequence.Items.Add(item);
            XmlSchemaAny any2 = new XmlSchemaAny();
            any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
            any2.MinOccurs = 1M;
            any2.ProcessContents = XmlSchemaContentProcessing.Lax;
            sequence.Items.Add(any2);
            XmlSchemaAttribute attribute = new XmlSchemaAttribute();
            attribute.Name = "namespace";
            attribute.FixedValue = dataset.Namespace;
            type.Attributes.Add(attribute);
            XmlSchemaAttribute attribute2 = new XmlSchemaAttribute();
            attribute2.Name = "tableTypeName";
            attribute2.FixedValue = "ZonesDataTable";
            type.Attributes.Add(attribute2);
            type.Particle = sequence;
            XmlSchema schemaSerializable = dataset.GetSchemaSerializable();
            if (xs.Contains(schemaSerializable.TargetNamespace))
            {
                MemoryStream stream = new MemoryStream();
                MemoryStream stream2 = new MemoryStream();
                try
                {
                    XmlSchema current = null;
                    schemaSerializable.Write(stream);
                    IEnumerator enumerator = xs.Schemas(schemaSerializable.TargetNamespace).GetEnumerator();
                    while (enumerator.MoveNext())
                    {
                        current = (XmlSchema) enumerator.Current;
                        stream2.SetLength(0L);
                        current.Write(stream2);
                        if (stream.Length == stream2.Length)
                        {
                            stream.Position = 0L;
                            stream2.Position = 0L;
                            while ((stream.Position != stream.Length) && (stream.ReadByte() == stream2.ReadByte()))
                            {
                            }
                            if (stream.Position == stream.Length)
                            {
                                return type;
                            }
                        }
                    }
                }
                finally
                {
                    if (stream != null)
                    {
                        stream.Close();
                    }
                    if (stream2 != null)
                    {
                        stream2.Close();
                    }
                }
            }
            xs.Add(schemaSerializable);
            return type;
        }

        [DebuggerNonUserCode]
        private void InitClass()
        {
            this.columnVisualizationID = new DataColumn("VisualizationID", typeof(int), null, MappingType.Element);
            base.Columns.Add(this.columnVisualizationID);
            this.columnZoneID = new DataColumn("ZoneID", typeof(int), null, MappingType.Element);
            base.Columns.Add(this.columnZoneID);
            this.columnName = new DataColumn("Name", typeof(string), null, MappingType.Element);
            base.Columns.Add(this.columnName);
            this.columnLoop = new DataColumn("Loop", typeof(bool), null, MappingType.Element);
            base.Columns.Add(this.columnLoop);
            this.columnFlags = new DataColumn("Flags", typeof(string), null, MappingType.Element);
            base.Columns.Add(this.columnFlags);
            this.columnFixed = new DataColumn("Fixed", typeof(bool), null, MappingType.Element);
            base.Columns.Add(this.columnFixed);
            this.columnID = new DataColumn("ID", typeof(int), null, MappingType.Element);
            base.Columns.Add(this.columnID);
            this.columnFlagsUsedForReplication = new DataColumn("FlagsUsedForReplication", typeof(string), null, MappingType.Element);
            base.Columns.Add(this.columnFlagsUsedForReplication);
            base.Constraints.Add(new UniqueConstraint("Constraint1", new DataColumn[] { this.columnZoneID }, true));
            this.columnVisualizationID.AllowDBNull = false;
            this.columnZoneID.AutoIncrement = true;
            this.columnZoneID.AllowDBNull = false;
            this.columnZoneID.ReadOnly = true;
            this.columnZoneID.Unique = true;
            this.columnName.AllowDBNull = false;
            this.columnName.MaxLength = 50;
            this.columnLoop.AllowDBNull = false;
            this.columnFlags.AllowDBNull = false;
            this.columnFlags.MaxLength = 4;
            this.columnFixed.AllowDBNull = false;
            this.columnID.AllowDBNull = false;
            this.columnFlagsUsedForReplication.AllowDBNull = false;
            this.columnFlagsUsedForReplication.MaxLength = 4;
        }

        [DebuggerNonUserCode]
        internal void InitVars()
        {
            this.columnVisualizationID = base.Columns["VisualizationID"];
            this.columnZoneID = base.Columns["ZoneID"];
            this.columnName = base.Columns["Name"];
            this.columnLoop = base.Columns["Loop"];
            this.columnFlags = base.Columns["Flags"];
            this.columnFixed = base.Columns["Fixed"];
            this.columnID = base.Columns["ID"];
            this.columnFlagsUsedForReplication = base.Columns["FlagsUsedForReplication"];
        }

        [DebuggerNonUserCode]
        protected override DataRow NewRowFromBuilder(DataRowBuilder builder)
        {
            return new ThemeDataset.ZonesRow(builder);
        }

        [DebuggerNonUserCode]
        public ThemeDataset.ZonesRow NewZonesRow()
        {
            return (ThemeDataset.ZonesRow) base.NewRow();
        }

        [DebuggerNonUserCode]
        protected override void OnRowChanged(DataRowChangeEventArgs e)
        {
            base.OnRowChanged(e);
            if (this.ZonesRowChanged != null)
            {
                this.ZonesRowChanged(this, new ThemeDataset.ZonesRowChangeEvent((ThemeDataset.ZonesRow) e.Row, e.Action));
            }
        }

        [DebuggerNonUserCode]
        protected override void OnRowChanging(DataRowChangeEventArgs e)
        {
            base.OnRowChanging(e);
            if (this.ZonesRowChanging != null)
            {
                this.ZonesRowChanging(this, new ThemeDataset.ZonesRowChangeEvent((ThemeDataset.ZonesRow) e.Row, e.Action));
            }
        }

        [DebuggerNonUserCode]
        protected override void OnRowDeleted(DataRowChangeEventArgs e)
        {
            base.OnRowDeleted(e);
            if (this.ZonesRowDeleted != null)
            {
                this.ZonesRowDeleted(this, new ThemeDataset.ZonesRowChangeEvent((ThemeDataset.ZonesRow) e.Row, e.Action));
            }
        }

        [DebuggerNonUserCode]
        protected override void OnRowDeleting(DataRowChangeEventArgs e)
        {
            base.OnRowDeleting(e);
            if (this.ZonesRowDeleting != null)
            {
                this.ZonesRowDeleting(this, new ThemeDataset.ZonesRowChangeEvent((ThemeDataset.ZonesRow) e.Row, e.Action));
            }
        }

        [DebuggerNonUserCode]
        public void RemoveZonesRow(ThemeDataset.ZonesRow row)
        {
            base.Rows.Remove(row);
        }

        // Properties
        [Browsable(false), DebuggerNonUserCode]
        public int Count
        {
            get
            {
                return base.Rows.Count;
            }
        }

        [DebuggerNonUserCode]
        public DataColumn FixedColumn
        {
            get
            {
                return this.columnFixed;
            }
        }

        [DebuggerNonUserCode]
        public DataColumn FlagsColumn
        {
            get
            {
                return this.columnFlags;
            }
        }

        [DebuggerNonUserCode]
        public DataColumn FlagsUsedForReplicationColumn
        {
            get
            {
                return this.columnFlagsUsedForReplication;
            }
        }

        [DebuggerNonUserCode]
        public DataColumn IDColumn
        {
            get
            {
                return this.columnID;
            }
        }

        [DebuggerNonUserCode]
        public ThemeDataset.ZonesRow this[int index]
        {
            get
            {
                return (ThemeDataset.ZonesRow) base.Rows[index];
            }
        }

        [DebuggerNonUserCode]
        public DataColumn LoopColumn
        {
            get
            {
                return this.columnLoop;
            }
        }

        [DebuggerNonUserCode]
        public DataColumn NameColumn
        {
            get
            {
                return this.columnName;
            }
        }

        [DebuggerNonUserCode]
        public DataColumn VisualizationIDColumn
        {
            get
            {
                return this.columnVisualizationID;
            }
        }

        [DebuggerNonUserCode]
        public DataColumn ZoneIDColumn
        {
            get
            {
                return this.columnZoneID;
            }
        }
    }

    [Serializable, GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0"), XmlSchemaProvider("GetTypedTableSchema")]
    public class ZonesGroupsDataTable : DataTable, IEnumerable
    {
        // Fields
        private DataColumn columnGroupID;
        private DataColumn columnZoneID;

        // Events
        public event ThemeDataset.ZonesGroupsRowChangeEventHandler ZonesGroupsRowChanged;

        public event ThemeDataset.ZonesGroupsRowChangeEventHandler ZonesGroupsRowChanging;

        public event ThemeDataset.ZonesGroupsRowChangeEventHandler ZonesGroupsRowDeleted;

        public event ThemeDataset.ZonesGroupsRowChangeEventHandler ZonesGroupsRowDeleting;

        // Methods
        [DebuggerNonUserCode]
        public ZonesGroupsDataTable()
        {
            base.TableName = "ZonesGroups";
            this.BeginInit();
            this.InitClass();
            this.EndInit();
        }

        [DebuggerNonUserCode]
        internal ZonesGroupsDataTable(DataTable table)
        {
            base.TableName = table.TableName;
            if (table.CaseSensitive != table.DataSet.CaseSensitive)
            {
                base.CaseSensitive = table.CaseSensitive;
            }
            if (table.Locale.ToString() != table.DataSet.Locale.ToString())
            {
                base.Locale = table.Locale;
            }
            if (table.Namespace != table.DataSet.Namespace)
            {
                base.Namespace = table.Namespace;
            }
            base.Prefix = table.Prefix;
            base.MinimumCapacity = table.MinimumCapacity;
        }

        [DebuggerNonUserCode]
        protected ZonesGroupsDataTable(SerializationInfo info, StreamingContext context) : base(info, context)
        {
            this.InitVars();
        }

        [DebuggerNonUserCode]
        public void AddZonesGroupsRow(ThemeDataset.ZonesGroupsRow row)
        {
            base.Rows.Add(row);
        }

        [DebuggerNonUserCode]
        public ThemeDataset.ZonesGroupsRow AddZonesGroupsRow(ThemeDataset.ZonesRow parentZonesRowByZonesGroups_Zones, ThemeDataset.GroupsRow parentGroupsRowByZonesGroups_Groups)
        {
            ThemeDataset.ZonesGroupsRow row = (ThemeDataset.ZonesGroupsRow) base.NewRow();
            object[] objArray = new object[2];
            if (parentZonesRowByZonesGroups_Zones != null)
            {
                objArray[0] = parentZonesRowByZonesGroups_Zones[1];
            }
            if (parentGroupsRowByZonesGroups_Groups != null)
            {
                objArray[1] = parentGroupsRowByZonesGroups_Groups[0];
            }
            row.ItemArray = objArray;
            base.Rows.Add(row);
            return row;
        }

        [DebuggerNonUserCode]
        public override DataTable Clone()
        {
            ThemeDataset.ZonesGroupsDataTable table = (ThemeDataset.ZonesGroupsDataTable) base.Clone();
            table.InitVars();
            return table;
        }

        [DebuggerNonUserCode]
        protected override DataTable CreateInstance()
        {
            return new ThemeDataset.ZonesGroupsDataTable();
        }

        [DebuggerNonUserCode]
        public ThemeDataset.ZonesGroupsRow FindByZoneIDGroupID(int ZoneID, int GroupID)
        {
            return (ThemeDataset.ZonesGroupsRow) base.Rows.Find(new object[] { ZoneID, GroupID });
        }

        [DebuggerNonUserCode]
        public virtual IEnumerator GetEnumerator()
        {
            return base.Rows.GetEnumerator();
        }

        [DebuggerNonUserCode]
        protected override Type GetRowType()
        {
            return typeof(ThemeDataset.ZonesGroupsRow);
        }

        [DebuggerNonUserCode]
        public static XmlSchemaComplexType GetTypedTableSchema(XmlSchemaSet xs)
        {
            XmlSchemaComplexType type = new XmlSchemaComplexType();
            XmlSchemaSequence sequence = new XmlSchemaSequence();
            ThemeDataset dataset = new ThemeDataset();
            XmlSchemaAny item = new XmlSchemaAny();
            item.Namespace = "http://www.w3.org/2001/XMLSchema";
            item.MinOccurs = 0M;
            item.MaxOccurs = 79228162514264337593543950335M;
            item.ProcessContents = XmlSchemaContentProcessing.Lax;
            sequence.Items.Add(item);
            XmlSchemaAny any2 = new XmlSchemaAny();
            any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
            any2.MinOccurs = 1M;
            any2.ProcessContents = XmlSchemaContentProcessing.Lax;
            sequence.Items.Add(any2);
            XmlSchemaAttribute attribute = new XmlSchemaAttribute();
            attribute.Name = "namespace";
            attribute.FixedValue = dataset.Namespace;
            type.Attributes.Add(attribute);
            XmlSchemaAttribute attribute2 = new XmlSchemaAttribute();
            attribute2.Name = "tableTypeName";
            attribute2.FixedValue = "ZonesGroupsDataTable";
            type.Attributes.Add(attribute2);
            type.Particle = sequence;
            XmlSchema schemaSerializable = dataset.GetSchemaSerializable();
            if (xs.Contains(schemaSerializable.TargetNamespace))
            {
                MemoryStream stream = new MemoryStream();
                MemoryStream stream2 = new MemoryStream();
                try
                {
                    XmlSchema current = null;
                    schemaSerializable.Write(stream);
                    IEnumerator enumerator = xs.Schemas(schemaSerializable.TargetNamespace).GetEnumerator();
                    while (enumerator.MoveNext())
                    {
                        current = (XmlSchema) enumerator.Current;
                        stream2.SetLength(0L);
                        current.Write(stream2);
                        if (stream.Length == stream2.Length)
                        {
                            stream.Position = 0L;
                            stream2.Position = 0L;
                            while ((stream.Position != stream.Length) && (stream.ReadByte() == stream2.ReadByte()))
                            {
                            }
                            if (stream.Position == stream.Length)
                            {
                                return type;
                            }
                        }
                    }
                }
                finally
                {
                    if (stream != null)
                    {
                        stream.Close();
                    }
                    if (stream2 != null)
                    {
                        stream2.Close();
                    }
                }
            }
            xs.Add(schemaSerializable);
            return type;
        }

        [DebuggerNonUserCode]
        private void InitClass()
        {
            this.columnZoneID = new DataColumn("ZoneID", typeof(int), null, MappingType.Element);
            base.Columns.Add(this.columnZoneID);
            this.columnGroupID = new DataColumn("GroupID", typeof(int), null, MappingType.Element);
            base.Columns.Add(this.columnGroupID);
            base.Constraints.Add(new UniqueConstraint("Constraint1", new DataColumn[] { this.columnZoneID, this.columnGroupID }, true));
            this.columnZoneID.AllowDBNull = false;
            this.columnGroupID.AllowDBNull = false;
        }

        [DebuggerNonUserCode]
        internal void InitVars()
        {
            this.columnZoneID = base.Columns["ZoneID"];
            this.columnGroupID = base.Columns["GroupID"];
        }

        [DebuggerNonUserCode]
        protected override DataRow NewRowFromBuilder(DataRowBuilder builder)
        {
            return new ThemeDataset.ZonesGroupsRow(builder);
        }

        [DebuggerNonUserCode]
        public ThemeDataset.ZonesGroupsRow NewZonesGroupsRow()
        {
            return (ThemeDataset.ZonesGroupsRow) base.NewRow();
        }

        [DebuggerNonUserCode]
        protected override void OnRowChanged(DataRowChangeEventArgs e)
        {
            base.OnRowChanged(e);
            if (this.ZonesGroupsRowChanged != null)
            {
                this.ZonesGroupsRowChanged(this, new ThemeDataset.ZonesGroupsRowChangeEvent((ThemeDataset.ZonesGroupsRow) e.Row, e.Action));
            }
        }

        [DebuggerNonUserCode]
        protected override void OnRowChanging(DataRowChangeEventArgs e)
        {
            base.OnRowChanging(e);
            if (this.ZonesGroupsRowChanging != null)
            {
                this.ZonesGroupsRowChanging(this, new ThemeDataset.ZonesGroupsRowChangeEvent((ThemeDataset.ZonesGroupsRow) e.Row, e.Action));
            }
        }

        [DebuggerNonUserCode]
        protected override void OnRowDeleted(DataRowChangeEventArgs e)
        {
            base.OnRowDeleted(e);
            if (this.ZonesGroupsRowDeleted != null)
            {
                this.ZonesGroupsRowDeleted(this, new ThemeDataset.ZonesGroupsRowChangeEvent((ThemeDataset.ZonesGroupsRow) e.Row, e.Action));
            }
        }

        [DebuggerNonUserCode]
        protected override void OnRowDeleting(DataRowChangeEventArgs e)
        {
            base.OnRowDeleting(e);
            if (this.ZonesGroupsRowDeleting != null)
            {
                this.ZonesGroupsRowDeleting(this, new ThemeDataset.ZonesGroupsRowChangeEvent((ThemeDataset.ZonesGroupsRow) e.Row, e.Action));
            }
        }

        [DebuggerNonUserCode]
        public void RemoveZonesGroupsRow(ThemeDataset.ZonesGroupsRow row)
        {
            base.Rows.Remove(row);
        }

        // Properties
        [DebuggerNonUserCode, Browsable(false)]
        public int Count
        {
            get
            {
                return base.Rows.Count;
            }
        }

        [DebuggerNonUserCode]
        public DataColumn GroupIDColumn
        {
            get
            {
                return this.columnGroupID;
            }
        }

        [DebuggerNonUserCode]
        public ThemeDataset.ZonesGroupsRow this[int index]
        {
            get
            {
                return (ThemeDataset.ZonesGroupsRow) base.Rows[index];
            }
        }

        [DebuggerNonUserCode]
        public DataColumn ZoneIDColumn
        {
            get
            {
                return this.columnZoneID;
            }
        }
    }

    [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
    public class ZonesGroupsRow : DataRow
    {
        // Fields
        private ThemeDataset.ZonesGroupsDataTable tableZonesGroups;

        // Methods
        [DebuggerNonUserCode]
        internal ZonesGroupsRow(DataRowBuilder rb) : base(rb)
        {
            this.tableZonesGroups = (ThemeDataset.ZonesGroupsDataTable) base.Table;
        }

        // Properties
        [DebuggerNonUserCode]
        public int GroupID
        {
            get
            {
                return (int) base[this.tableZonesGroups.GroupIDColumn];
            }
            set
            {
                base[this.tableZonesGroups.GroupIDColumn] = value;
            }
        }

        [DebuggerNonUserCode]
        public ThemeDataset.GroupsRow GroupsRow
        {
            get
            {
                return (ThemeDataset.GroupsRow) base.GetParentRow(base.Table.ParentRelations["ZonesGroups_Groups"]);
            }
            set
            {
                base.SetParentRow(value, base.Table.ParentRelations["ZonesGroups_Groups"]);
            }
        }

        [DebuggerNonUserCode]
        public int ZoneID
        {
            get
            {
                return (int) base[this.tableZonesGroups.ZoneIDColumn];
            }
            set
            {
                base[this.tableZonesGroups.ZoneIDColumn] = value;
            }
        }

        [DebuggerNonUserCode]
        public ThemeDataset.ZonesRow ZonesRow
        {
            get
            {
                return (ThemeDataset.ZonesRow) base.GetParentRow(base.Table.ParentRelations["ZonesGroups_Zones"]);
            }
            set
            {
                base.SetParentRow(value, base.Table.ParentRelations["ZonesGroups_Zones"]);
            }
        }
    }

    [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
    public class ZonesGroupsRowChangeEvent : EventArgs
    {
        // Fields
        private DataRowAction eventAction;
        private ThemeDataset.ZonesGroupsRow eventRow;

        // Methods
        [DebuggerNonUserCode]
        public ZonesGroupsRowChangeEvent(ThemeDataset.ZonesGroupsRow row, DataRowAction action)
        {
            this.eventRow = row;
            this.eventAction = action;
        }

        // Properties
        [DebuggerNonUserCode]
        public DataRowAction Action
        {
            get
            {
                return this.eventAction;
            }
        }

        [DebuggerNonUserCode]
        public ThemeDataset.ZonesGroupsRow Row
        {
            get
            {
                return this.eventRow;
            }
        }
    }

    public delegate void ZonesGroupsRowChangeEventHandler(object sender, ThemeDataset.ZonesGroupsRowChangeEvent e);

    [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
    public class ZonesRow : DataRow
    {
        // Fields
        private ThemeDataset.ZonesDataTable tableZones;

        // Methods
        [DebuggerNonUserCode]
        internal ZonesRow(DataRowBuilder rb) : base(rb)
        {
            this.tableZones = (ThemeDataset.ZonesDataTable) base.Table;
        }

        [DebuggerNonUserCode]
        public ThemeDataset.ActionsRow[] GetActionsRows()
        {
            if (base.Table.ChildRelations["Actions_Zones"] == null)
            {
                return new ThemeDataset.ActionsRow[0];
            }
            return (ThemeDataset.ActionsRow[]) base.GetChildRows(base.Table.ChildRelations["Actions_Zones"]);
        }

        [DebuggerNonUserCode]
        public ThemeDataset.ZonesGroupsRow[] GetZonesGroupsRows()
        {
            if (base.Table.ChildRelations["ZonesGroups_Zones"] == null)
            {
                return new ThemeDataset.ZonesGroupsRow[0];
            }
            return (ThemeDataset.ZonesGroupsRow[]) base.GetChildRows(base.Table.ChildRelations["ZonesGroups_Zones"]);
        }

        // Properties
        [DebuggerNonUserCode]
        public bool Fixed
        {
            get
            {
                return (bool) base[this.tableZones.FixedColumn];
            }
            set
            {
                base[this.tableZones.FixedColumn] = value;
            }
        }

        [DebuggerNonUserCode]
        public string Flags
        {
            get
            {
                return (string) base[this.tableZones.FlagsColumn];
            }
            set
            {
                base[this.tableZones.FlagsColumn] = value;
            }
        }

        [DebuggerNonUserCode]
        public string FlagsUsedForReplication
        {
            get
            {
                return (string) base[this.tableZones.FlagsUsedForReplicationColumn];
            }
            set
            {
                base[this.tableZones.FlagsUsedForReplicationColumn] = value;
            }
        }

        [DebuggerNonUserCode]
        public int ID
        {
            get
            {
                return (int) base[this.tableZones.IDColumn];
            }
            set
            {
                base[this.tableZones.IDColumn] = value;
            }
        }

        [DebuggerNonUserCode]
        public bool Loop
        {
            get
            {
                return (bool) base[this.tableZones.LoopColumn];
            }
            set
            {
                base[this.tableZones.LoopColumn] = value;
            }
        }

        [DebuggerNonUserCode]
        public string Name
        {
            get
            {
                return (string) base[this.tableZones.NameColumn];
            }
            set
            {
                base[this.tableZones.NameColumn] = value;
            }
        }

        [DebuggerNonUserCode]
        public int VisualizationID
        {
            get
            {
                return (int) base[this.tableZones.VisualizationIDColumn];
            }
            set
            {
                base[this.tableZones.VisualizationIDColumn] = value;
            }
        }

        [DebuggerNonUserCode]
        public ThemeDataset.VisualizationsRow VisualizationsRow
        {
            get
            {
                return (ThemeDataset.VisualizationsRow) base.GetParentRow(base.Table.ParentRelations["Zones_Visualizations"]);
            }
            set
            {
                base.SetParentRow(value, base.Table.ParentRelations["Zones_Visualizations"]);
            }
        }

        [DebuggerNonUserCode]
        public int ZoneID
        {
            get
            {
                return (int) base[this.tableZones.ZoneIDColumn];
            }
            set
            {
                base[this.tableZones.ZoneIDColumn] = value;
            }
        }
    }

    [GeneratedCode("System.Data.Design.TypedDataSetGenerator", "2.0.0.0")]
    public class ZonesRowChangeEvent : EventArgs
    {
        // Fields
        private DataRowAction eventAction;
        private ThemeDataset.ZonesRow eventRow;

        // Methods
        [DebuggerNonUserCode]
        public ZonesRowChangeEvent(ThemeDataset.ZonesRow row, DataRowAction action)
        {
            this.eventRow = row;
            this.eventAction = action;
        }

        // Properties
        [DebuggerNonUserCode]
        public DataRowAction Action
        {
            get
            {
                return this.eventAction;
            }
        }

        [DebuggerNonUserCode]
        public ThemeDataset.ZonesRow Row
        {
            get
            {
                return this.eventRow;
            }
        }
    }

    public delegate void ZonesRowChangeEventHandler(object sender, ThemeDataset.ZonesRowChangeEvent e);
}

 }
